Source/WebKit/ChangeLog

 12022-04-21 Sihui Liu <sihui_liu@apple.com>
 2
 3 WebProcessProxy should not hold WebsiteDataStore alive when there is no page
 4 https://bugs.webkit.org/show_bug.cgi?id=238892
 5
 6 Reviewed by NOBODY (OOPS!).
 7
 8 WebProcessProxy can outlive WebPageProxy, and because WebProcessProxy holds strong reference to WebsiteDataStore,
 9 WebsiteDataStore will be kept alive even when it's not used by any page and will not be used by any page.
 10
 11 * UIProcess/GPU/GPUProcessProxy.cpp:
 12 (WebKit::GPUProcessProxy::getGPUProcessConnection):
 13 * UIProcess/ProvisionalPageProxy.cpp:
 14 (WebKit::ProvisionalPageProxy::ProvisionalPageProxy):
 15 (WebKit::ProvisionalPageProxy::~ProvisionalPageProxy):
 16 * UIProcess/ProvisionalPageProxy.h:
 17 (WebKit::ProvisionalPageProxy::websiteDataStore const):
 18 * UIProcess/SuspendedPageProxy.cpp:
 19 (WebKit::SuspendedPageProxy::findReusableSuspendedPageProcess):
 20 * UIProcess/WebBackForwardCache.cpp:
 21 (WebKit::WebBackForwardCache::removeEntriesForSession):
 22 * UIProcess/WebLockRegistryProxy.cpp:
 23 (WebKit::WebLockRegistryProxy::requestLock):
 24 (WebKit::WebLockRegistryProxy::releaseLock):
 25 (WebKit::WebLockRegistryProxy::abortLockRequest):
 26 (WebKit::WebLockRegistryProxy::snapshot):
 27 (WebKit::WebLockRegistryProxy::clientIsGoingAway):
 28 (WebKit::WebLockRegistryProxy::processDidExit):
 29 * UIProcess/WebPageProxy.cpp:
 30 (WebKit::WebPageProxy::swapToProvisionalPage):
 31 (WebKit::WebPageProxy::commitProvisionalPage):
 32 * UIProcess/WebProcessCache.cpp:
 33 (WebKit::WebProcessCache::canCacheProcess const):
 34 (WebKit::WebProcessCache::takeProcess):
 35 (WebKit::WebProcessCache::clearAllProcessesForSession):
 36 (WebKit::WebProcessCache::CachedProcess::CachedProcess):
 37 * UIProcess/WebProcessPool.cpp:
 38 (WebKit::WebProcessPool::establishRemoteWorkerContextConnectionToNetworkProcess):
 39 (WebKit::WebProcessPool::processForRegistrableDomain):
 40 (WebKit::WebProcessPool::createWebPage):
 41 (WebKit::WebProcessPool::pageBeginUsingWebsiteDataStore):
 42 (WebKit::WebProcessPool::pageEndUsingWebsiteDataStore):
 43 (WebKit::WebProcessPool::hasPagesUsingWebsiteDataStore const):
 44 (WebKit::WebProcessPool::processForNavigationInternal):
 45 * UIProcess/WebProcessPool.h:
 46 * UIProcess/WebProcessProxy.cpp:
 47 (WebKit::WebProcessProxy::WebProcessProxy):
 48 (WebKit::m_webLockRegistry):
 49 (WebKit::WebProcessProxy::setWebsiteDataStore):
 50 (WebKit::WebProcessProxy::isDummyProcessProxy const):
 51 (WebKit::WebProcessProxy::updateRegistrationWithDataStore):
 52 (WebKit::WebProcessProxy::addExistingWebPage):
 53 (WebKit::WebProcessProxy::removeWebPage):
 54 (WebKit::WebProcessProxy::getNetworkProcessConnection):
 55 (WebKit::WebProcessProxy::didStartProvisionalLoadForMainFrame):
 56 (WebKit::WebProcessProxy::sessionID const):
 57 * UIProcess/WebProcessProxy.h:
 58 (WebKit::WebProcessProxy::websiteDataStore const): Deleted.
 59 * UIProcess/glib/WebProcessProxyGLib.cpp:
 60 (WebKit::WebProcessProxy::platformGetLaunchOptions):
 61
1622022-04-21 Eric Carlson <eric.carlson@apple.com>
263
364 AVSampleBufferRenderSynchronizer timeline sometimes goes backwards when playback begins

Source/WebKit/UIProcess/GPU/GPUProcessProxy.cpp

@@void GPUProcessProxy::processWillShutDown(IPC::Connection& connection)
387387
388388void GPUProcessProxy::getGPUProcessConnection(WebProcessProxy& webProcessProxy, const GPUProcessConnectionParameters& parameters, Messages::WebProcessProxy::GetGPUProcessConnection::DelayedReply&& reply)
389389{
390  addSession(webProcessProxy.websiteDataStore());
 390 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(webProcessProxy.sessionID()))
 391 addSession(*dataStore);
391392
392393 RELEASE_LOG(ProcessSuspension, "%p - GPUProcessProxy is taking a background assertion because a web process is requesting a connection", this);
393394 startResponsivenessTimer(UseLazyStop::No);

Source/WebKit/UIProcess/ProvisionalPageProxy.cpp

@@ProvisionalPageProxy::ProvisionalPageProxy(WebPageProxy& page, Ref<WebProcessPro
8484 m_process->addMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_webPageID, *this);
8585 m_process->addProvisionalPageProxy(*this);
8686
87  if (&m_process->websiteDataStore() != &m_page.websiteDataStore())
88  m_process->processPool().pageBeginUsingWebsiteDataStore(m_page.identifier(), m_process->websiteDataStore());
 87 auto processSessionID = m_process->sessionID();
 88 if (processSessionID != m_page.websiteDataStore().sessionID())
 89 m_process->processPool().pageBeginUsingWebsiteDataStore(m_page.identifier(), processSessionID);
 90 m_websiteDataStore = WebsiteDataStore::existingDataStoreForSessionID(processSessionID);
 91 ASSERT(m_websiteDataStore);
8992
9093 // If we are reattaching to a SuspendedPage, then the WebProcess' WebPage already exists and
9194 // WebPageProxy::didCreateMainFrame() will not be called to initialize m_mainFrame. In such

@@ProvisionalPageProxy::~ProvisionalPageProxy()
113116 if (!m_wasCommitted) {
114117 m_page.inspectorController().willDestroyProvisionalPage(*this);
115118
116  if (&m_process->websiteDataStore() != &m_page.websiteDataStore())
117  m_process->processPool().pageEndUsingWebsiteDataStore(m_page.identifier(), m_process->websiteDataStore());
 119 if (m_process->sessionID() != m_page.websiteDataStore().sessionID())
 120 m_process->processPool().pageEndUsingWebsiteDataStore(m_page.identifier(), m_process->sessionID());
118121
119122 m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_webPageID);
120123 send(Messages::WebPage::Close());

Source/WebKit/UIProcess/ProvisionalPageProxy.h

@@class UserData;
6161class WebFrameProxy;
6262class WebPageProxy;
6363class WebProcessProxy;
 64class WebsiteDataStore;
6465struct FrameInfoData;
6566struct NavigationActionData;
6667struct URLSchemeTaskParameters;

@@public:
8384 ProcessSwapRequestedByClient processSwapRequestedByClient() const { return m_processSwapRequestedByClient; }
8485 uint64_t navigationID() const { return m_navigationID; }
8586 const URL& provisionalURL() const { return m_provisionalLoadURL; }
 87 WebsiteDataStore* websiteDataStore() const { return m_websiteDataStore.get(); }
8688
8789 bool isProcessSwappingOnNavigationResponse() const { return m_isProcessSwappingOnNavigationResponse; }
8890

@@private:
163165 WebPageProxy& m_page;
164166 WebCore::PageIdentifier m_webPageID;
165167 Ref<WebProcessProxy> m_process;
 168 RefPtr<WebsiteDataStore> m_websiteDataStore;
166169 std::unique_ptr<DrawingAreaProxy> m_drawingArea;
167170 RefPtr<WebFrameProxy> m_mainFrame;
168171 uint64_t m_navigationID;

Source/WebKit/UIProcess/SuspendedPageProxy.cpp

@@RefPtr<WebProcessProxy> SuspendedPageProxy::findReusableSuspendedPageProcess(Web
5353{
5454 for (auto* suspendedPage : allSuspendedPages()) {
5555 auto& process = suspendedPage->process();
56  if (&process.processPool() == &processPool && process.registrableDomain() == registrableDomain && &process.websiteDataStore() == &dataStore && process.crossOriginMode() != CrossOriginMode::Isolated && process.captivePortalMode() == captivePortalMode)
 56 if (&process.processPool() == &processPool && process.registrableDomain() == registrableDomain && process.sessionID() == dataStore.sessionID() && process.crossOriginMode() != CrossOriginMode::Isolated && process.captivePortalMode() == captivePortalMode)
5757 return &process;
5858 }
5959 return nullptr;

Source/WebKit/UIProcess/WebBackForwardCache.cpp

@@void WebBackForwardCache::removeEntriesForProcess(WebProcessProxy& process)
134134void WebBackForwardCache::removeEntriesForSession(PAL::SessionID sessionID)
135135{
136136 removeEntriesMatching([sessionID](auto& item) {
137  return item.backForwardCacheEntry()->process().websiteDataStore().sessionID() == sessionID;
 137 return item.backForwardCacheEntry()->process().sessionID() == sessionID;
138138 });
139139}
140140

Source/WebKit/UIProcess/WebLockRegistryProxy.cpp

3232#include "WebProcessProxy.h"
3333#include "WebsiteDataStore.h"
3434#include <WebCore/WebLockIdentifier.h>
 35#include <WebCore/WebLockManagerSnapshot.h>
3536#include <WebCore/WebLockRegistry.h>
3637
3738namespace WebKit {

@@void WebLockRegistryProxy::requestLock(WebCore::ClientOrigin&& clientOrigin, Web
5556 MESSAGE_CHECK(clientID.processIdentifier() == m_process.coreProcessIdentifier());
5657 m_hasEverRequestedLocks = true;
5758
58  m_process.websiteDataStore().webLockRegistry().requestLock(WTFMove(clientOrigin), lockIdentifier, clientID, WTFMove(name), lockMode, steal, ifAvailable, [weakThis = WeakPtr { *this }, lockIdentifier, clientID](bool success) {
59  if (weakThis)
60  weakThis->m_process.send(Messages::RemoteWebLockRegistry::DidCompleteLockRequest(lockIdentifier, clientID, success), 0);
61  }, [weakThis = WeakPtr { *this }, lockIdentifier, clientID] {
62  if (weakThis)
63  weakThis->m_process.send(Messages::RemoteWebLockRegistry::DidStealLock(lockIdentifier, clientID), 0);
64  });
 59 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_process.sessionID())) {
 60 dataStore->webLockRegistry().requestLock(WTFMove(clientOrigin), lockIdentifier, clientID, WTFMove(name), lockMode, steal, ifAvailable, [weakThis = WeakPtr { *this }, lockIdentifier, clientID](bool success) {
 61 if (weakThis)
 62 weakThis->m_process.send(Messages::RemoteWebLockRegistry::DidCompleteLockRequest(lockIdentifier, clientID, success), 0);
 63 }, [weakThis = WeakPtr { *this }, lockIdentifier, clientID] {
 64 if (weakThis)
 65 weakThis->m_process.send(Messages::RemoteWebLockRegistry::DidStealLock(lockIdentifier, clientID), 0);
 66 });
 67 } else
 68 m_process.send(Messages::RemoteWebLockRegistry::DidCompleteLockRequest(lockIdentifier, clientID, false), 0);
6569}
6670
6771void WebLockRegistryProxy::releaseLock(WebCore::ClientOrigin&& clientOrigin, WebCore::WebLockIdentifier lockIdentifier, WebCore::ScriptExecutionContextIdentifier clientID, String&& name)
6872{
6973 MESSAGE_CHECK(lockIdentifier.processIdentifier() == m_process.coreProcessIdentifier());
7074 MESSAGE_CHECK(clientID.processIdentifier() == m_process.coreProcessIdentifier());
71  m_process.websiteDataStore().webLockRegistry().releaseLock(WTFMove(clientOrigin), lockIdentifier, clientID, WTFMove(name));
 75 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_process.sessionID()))
 76 dataStore->webLockRegistry().releaseLock(WTFMove(clientOrigin), lockIdentifier, clientID, WTFMove(name));
7277}
7378
7479void WebLockRegistryProxy::abortLockRequest(WebCore::ClientOrigin&& clientOrigin, WebCore::WebLockIdentifier lockIdentifier, WebCore::ScriptExecutionContextIdentifier clientID, String&& name, CompletionHandler<void(bool)>&& completionHandler)
7580{
7681 MESSAGE_CHECK(lockIdentifier.processIdentifier() == m_process.coreProcessIdentifier());
7782 MESSAGE_CHECK(clientID.processIdentifier() == m_process.coreProcessIdentifier());
78  m_process.websiteDataStore().webLockRegistry().abortLockRequest(WTFMove(clientOrigin), lockIdentifier, clientID, WTFMove(name), WTFMove(completionHandler));
 83 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_process.sessionID()))
 84 dataStore->webLockRegistry().abortLockRequest(WTFMove(clientOrigin), lockIdentifier, clientID, WTFMove(name), WTFMove(completionHandler));
 85 else
 86 completionHandler(false);
7987}
8088
8189void WebLockRegistryProxy::snapshot(WebCore::ClientOrigin&& clientOrigin, CompletionHandler<void(WebCore::WebLockManagerSnapshot&&)>&& completionHandler)
8290{
83  m_process.websiteDataStore().webLockRegistry().snapshot(WTFMove(clientOrigin), WTFMove(completionHandler));
 91 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_process.sessionID()))
 92 dataStore->webLockRegistry().snapshot(WTFMove(clientOrigin), WTFMove(completionHandler));
 93 else
 94 completionHandler(WebCore::WebLockManagerSnapshot { });
8495}
8596
8697void WebLockRegistryProxy::clientIsGoingAway(WebCore::ClientOrigin&& clientOrigin, WebCore::ScriptExecutionContextIdentifier clientID)
8798{
8899 MESSAGE_CHECK(clientID.processIdentifier() == m_process.coreProcessIdentifier());
89  m_process.websiteDataStore().webLockRegistry().clientIsGoingAway(WTFMove(clientOrigin), clientID);
 100 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_process.sessionID()))
 101 dataStore->webLockRegistry().clientIsGoingAway(WTFMove(clientOrigin), clientID);
90102}
91103
92104void WebLockRegistryProxy::processDidExit()
93105{
94  if (m_hasEverRequestedLocks)
95  m_process.websiteDataStore().webLockRegistry().clientsAreGoingAway(m_process.coreProcessIdentifier());
 106 if (!m_hasEverRequestedLocks)
 107 return;
 108
 109 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_process.sessionID()))
 110 dataStore->webLockRegistry().clientsAreGoingAway(m_process.coreProcessIdentifier());
96111}
97112
98113#undef MESSAGE_CHECK

Source/WebKit/UIProcess/WebPageProxy.cpp

@@void WebPageProxy::swapToProvisionalPage(std::unique_ptr<ProvisionalPageProxy> p
978978 m_process = provisionalPage->process();
979979 m_webPageID = provisionalPage->webPageID();
980980 pageClient().didChangeWebPageID();
981  m_websiteDataStore = m_process->websiteDataStore();
 981 m_websiteDataStore = *provisionalPage->websiteDataStore();
982982
983983#if HAVE(VISIBILITY_PROPAGATION_VIEW)
984984 m_contextIDForVisibilityPropagationInWebProcess = provisionalPage->contextIDForVisibilityPropagationInWebProcess();

@@void WebPageProxy::commitProvisionalPage(FrameIdentifier frameID, FrameInfoData&
36143614 removeAllMessageReceivers();
36153615 auto* navigation = navigationState().navigation(m_provisionalPage->navigationID());
36163616 bool didSuspendPreviousPage = navigation && !m_provisionalPage->isProcessSwappingOnNavigationResponse() ? suspendCurrentPageIfPossible(*navigation, mainFrameIDInPreviousProcess, m_provisionalPage->processSwapRequestedByClient(), shouldDelayClosingUntilFirstLayerFlush) : false;
3617  m_process->removeWebPage(*this, m_websiteDataStore.ptr() == &m_provisionalPage->process().websiteDataStore() ? WebProcessProxy::EndsUsingDataStore::No : WebProcessProxy::EndsUsingDataStore::Yes);
 3617 m_process->removeWebPage(*this, m_websiteDataStore.ptr() == m_provisionalPage->websiteDataStore() ? WebProcessProxy::EndsUsingDataStore::No : WebProcessProxy::EndsUsingDataStore::Yes);
36183618
36193619 // There is no way we'll be able to return to the page in the previous page so close it.
36203620 if (!didSuspendPreviousPage)

Source/WebKit/UIProcess/WebProcessCache.cpp

@@bool WebProcessCache::canCacheProcess(WebProcessProxy& process) const
7676 return false;
7777 }
7878
79  auto sessionID = process.websiteDataStore().sessionID();
80  if (sessionID.isEphemeral() && !process.processPool().hasPagesUsingWebsiteDataStore(process.websiteDataStore())) {
 79 if (!WebsiteDataStore::existingDataStoreForSessionID(process.sessionID())) {
8180 WEBPROCESSCACHE_RELEASE_LOG("canCacheProcess: Not caching process because this session has been destroyed", process.processIdentifier());
8281 return false;
8382 }

@@RefPtr<WebProcessProxy> WebProcessCache::takeProcess(const WebCore::RegistrableD
153152 if (it == m_processesPerRegistrableDomain.end())
154153 return nullptr;
155154
156  if (&it->value->process().websiteDataStore() != &dataStore)
 155 if (it->value->process().sessionID() != dataStore.sessionID())
157156 return nullptr;
158157
159158 if (it->value->process().captivePortalMode() != captivePortalMode)

@@void WebProcessCache::clearAllProcessesForSession(PAL::SessionID sessionID)
212211{
213212 Vector<WebCore::RegistrableDomain> keysToRemove;
214213 for (auto& pair : m_processesPerRegistrableDomain) {
215  if (pair.value->process().websiteDataStore().sessionID() == sessionID) {
 214 if (pair.value->process().sessionID() == sessionID) {
216215 WEBPROCESSCACHE_RELEASE_LOG("clearAllProcessesForSession: Evicting process because its session was destroyed", pair.value->process().processIdentifier());
217216 keysToRemove.append(pair.key);
218217 }

@@void WebProcessCache::clearAllProcessesForSession(PAL::SessionID sessionID)
222221
223222 Vector<uint64_t> pendingRequestsToRemove;
224223 for (auto& pair : m_pendingAddRequests) {
225  if (pair.value->process().websiteDataStore().sessionID() == sessionID) {
 224 if (pair.value->process().sessionID() == sessionID) {
226225 WEBPROCESSCACHE_RELEASE_LOG("clearAllProcessesForSession: Evicting process because its session was destroyed", pair.value->process().processIdentifier());
227226 pendingRequestsToRemove.append(pair.key);
228227 }

@@WebProcessCache::CachedProcess::CachedProcess(Ref<WebProcessProxy>&& process)
276275#endif
277276{
278277 RELEASE_ASSERT(!m_process->pageCount());
279  RELEASE_ASSERT_WITH_MESSAGE(!m_process->websiteDataStore().processes().contains(*m_process), "Only processes with pages should be registered with the data store");
 278 auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_process->sessionID());
 279 RELEASE_ASSERT(dataStore);
 280 RELEASE_ASSERT_WITH_MESSAGE(!dataStore->processes().contains(*m_process), "Only processes with pages should be registered with the data store");
280281 m_process->setIsInProcessCache(true);
281282 m_evictionTimer.startOneShot(cachedProcessLifetime);
282283}

Source/WebKit/UIProcess/WebProcessPool.cpp

@@void WebProcessPool::establishRemoteWorkerContextConnectionToNetworkProcess(Remo
572572
573573 // Prioritize the requesting WebProcess for running the service worker.
574574 if (!remoteWorkerProcessProxy && !shouldUseSeparateRemoteWorkerProcess && requestingProcess) {
575  if (&requestingProcess->websiteDataStore() == websiteDataStore && requestingProcess->isMatchingRegistrableDomain(registrableDomain))
 575 if (requestingProcess->sessionID() == websiteDataStore->sessionID() && requestingProcess->isMatchingRegistrableDomain(registrableDomain))
576576 useProcessForRemoteWorkers(*requestingProcess);
577577 }
578578

@@void WebProcessPool::establishRemoteWorkerContextConnectionToNetworkProcess(Remo
580580 for (auto& process : processPool->m_processes) {
581581 if (process.ptr() == processPool->m_prewarmedProcess.get() || process->isDummyProcessProxy())
582582 continue;
583  if (&process->websiteDataStore() != websiteDataStore)
 583 if (process->sessionID() != websiteDataStore->sessionID())
584584 continue;
585585 if (!process->isMatchingRegistrableDomain(registrableDomain))
586586 continue;

@@Ref<WebProcessProxy> WebProcessPool::processForRegistrableDomain(WebsiteDataStor
10861086 if (process->isRunningServiceWorkers())
10871087 continue;
10881088#endif
1089  if (mustMatchDataStore && &process->websiteDataStore() != &websiteDataStore)
 1089 if (mustMatchDataStore && process->sessionID() != websiteDataStore.sessionID())
10901090 continue;
10911091 return process;
10921092 }

@@Ref<WebPageProxy> WebProcessPool::createWebPage(PageClient& pageClient, Ref<API:
11261126 // Sharing processes, e.g. when creating the page via window.open().
11271127 process = &pageConfiguration->relatedPage()->ensureRunningProcess();
11281128 // We do not support several WebsiteDataStores sharing a single process.
1129  ASSERT(process->isDummyProcessProxy() || pageConfiguration->websiteDataStore() == &process->websiteDataStore());
 1129 ASSERT(process->isDummyProcessProxy() || pageConfiguration->websiteDataStore()->sessionID() == process->sessionID());
11301130 ASSERT(&pageConfiguration->relatedPage()->websiteDataStore() == pageConfiguration->websiteDataStore());
11311131 } else if (!m_isDelayedWebProcessLaunchDisabled) {
11321132 // In the common case, we delay process launch until something is actually loaded in the page.

@@void WebProcessPool::updateRemoteWorkerUserAgent(const String& userAgent)
11831183 workerProcess.setRemoteWorkerUserAgent(m_remoteWorkerUserAgent);
11841184}
11851185
1186 void WebProcessPool::pageBeginUsingWebsiteDataStore(WebPageProxyIdentifier pageID, WebsiteDataStore& dataStore)
 1186void WebProcessPool::pageBeginUsingWebsiteDataStore(WebPageProxyIdentifier pageID, PAL::SessionID sessionID)
11871187{
11881188 RELEASE_ASSERT(RunLoop::isMain());
1189  RELEASE_ASSERT(m_sessionToPageIDsMap.isValidKey(dataStore.sessionID()));
1190  auto result = m_sessionToPageIDsMap.add(dataStore.sessionID(), HashSet<WebPageProxyIdentifier>()).iterator->value.add(pageID);
 1189 RELEASE_ASSERT(m_sessionToPageIDsMap.isValidKey(sessionID));
 1190 auto result = m_sessionToPageIDsMap.add(sessionID, HashSet<WebPageProxyIdentifier>()).iterator->value.add(pageID);
11911191 ASSERT_UNUSED(result, result.isNewEntry);
11921192}
11931193
1194 void WebProcessPool::pageEndUsingWebsiteDataStore(WebPageProxyIdentifier pageID, WebsiteDataStore& dataStore)
 1194void WebProcessPool::pageEndUsingWebsiteDataStore(WebPageProxyIdentifier pageID, PAL::SessionID sessionID)
11951195{
11961196 RELEASE_ASSERT(RunLoop::isMain());
1197  auto sessionID = dataStore.sessionID();
1198  RELEASE_ASSERT(m_sessionToPageIDsMap.isValidKey(dataStore.sessionID()));
 1197 RELEASE_ASSERT(m_sessionToPageIDsMap.isValidKey(sessionID));
11991198 auto iterator = m_sessionToPageIDsMap.find(sessionID);
12001199 RELEASE_ASSERT(iterator != m_sessionToPageIDsMap.end());
12011200

@@void WebProcessPool::pageEndUsingWebsiteDataStore(WebPageProxyIdentifier pageID,
12101209 }
12111210}
12121211
1213 bool WebProcessPool::hasPagesUsingWebsiteDataStore(WebsiteDataStore& dataStore) const
 1212bool WebProcessPool::hasPagesUsingWebsiteDataStore(PAL::SessionID sessionID) const
12141213{
12151214 RELEASE_ASSERT(RunLoop::isMain());
1216  RELEASE_ASSERT(m_sessionToPageIDsMap.isValidKey(dataStore.sessionID()));
1217  return m_sessionToPageIDsMap.contains(dataStore.sessionID());
 1215 RELEASE_ASSERT(m_sessionToPageIDsMap.isValidKey(sessionID));
 1216 return m_sessionToPageIDsMap.contains(sessionID);
12181217}
12191218
12201219DownloadProxy& WebProcessPool::download(WebsiteDataStore& dataStore, WebPageProxy* initiatingPage, const ResourceRequest& request, const String& suggestedFilename)

@@void WebProcessPool::processForNavigationInternal(WebPageProxy& page, const API:
19761975 LOG(ProcessSwapping, "(ProcessSwapping) Considering re-use of a previously cached process for domain %s", targetRegistrableDomain.string().utf8().data());
19771976
19781977 if (auto* process = m_swappedProcessesPerRegistrableDomain.get(targetRegistrableDomain)) {
1979  if (&process->websiteDataStore() == dataStore.ptr()) {
 1978 if (process->sessionID() == dataStore->sessionID()) {
19801979 LOG(ProcessSwapping, "(ProcessSwapping) Reusing a previously cached process with pid %i to continue navigation to URL %s", process->processIdentifier(), targetURL.string().utf8().data());
19811980
19821981 return completionHandler(*process, nullptr, reason);

Source/WebKit/UIProcess/WebProcessPool.h

@@public:
214214
215215 Ref<WebPageProxy> createWebPage(PageClient&, Ref<API::PageConfiguration>&&);
216216
217  void pageBeginUsingWebsiteDataStore(WebPageProxyIdentifier, WebsiteDataStore&);
218  void pageEndUsingWebsiteDataStore(WebPageProxyIdentifier, WebsiteDataStore&);
219  bool hasPagesUsingWebsiteDataStore(WebsiteDataStore&) const;
 217 void pageBeginUsingWebsiteDataStore(WebPageProxyIdentifier, PAL::SessionID);
 218 void pageEndUsingWebsiteDataStore(WebPageProxyIdentifier, PAL::SessionID);
 219 bool hasPagesUsingWebsiteDataStore(PAL::SessionID) const;
220220
221221 const String& injectedBundlePath() const { return m_configuration->injectedBundlePath(); }
222222#if PLATFORM(COCOA)

Source/WebKit/UIProcess/WebProcessProxy.cpp

@@WebProcessProxy::WebProcessProxy(WebProcessPool& processPool, WebsiteDataStore*
241241#endif
242242 , m_isResponsive(NoOrMaybe::Maybe)
243243 , m_visiblePageCounter([this](RefCounterEvent) { updateBackgroundResponsivenessTimer(); })
244  , m_websiteDataStore(websiteDataStore)
245244#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)
246245 , m_userMediaCaptureManagerProxy(makeUnique<UserMediaCaptureManagerProxy>(makeUniqueRef<UIProxyForCapture>(*this)))
247246#endif

@@WebProcessProxy::WebProcessProxy(WebProcessPool& processPool, WebsiteDataStore*
258257 ASSERT_UNUSED(result, result.isNewEntry);
259258
260259 WebPasteboardProxy::singleton().addWebProcessProxy(*this);
261 
 260 if (websiteDataStore)
 261 m_sessionID = websiteDataStore->sessionID();
262262 platformInitialize();
263263}
264264

@@void WebProcessProxy::setIsInProcessCache(bool value, WillShutDown willShutDown)
348348
349349void WebProcessProxy::setWebsiteDataStore(WebsiteDataStore& dataStore)
350350{
351  ASSERT(!m_websiteDataStore);
 351 ASSERT(!m_sessionID.isValid());
352352 WEBPROCESSPROXY_RELEASE_LOG(Process, "setWebsiteDataStore() dataStore=%p, sessionID=%" PRIu64, &dataStore, dataStore.sessionID().toUInt64());
353  m_websiteDataStore = &dataStore;
354353 updateRegistrationWithDataStore();
355354 send(Messages::WebProcess::SetWebsiteDataStoreParameters(processPool().webProcessDataStoreParameters(*this, dataStore)), 0);
356355
357356 // Delay construction of the WebLockRegistryProxy until the WebProcessProxy has a data store since the data store holds the
358357 // LocalWebLockRegistry.
359358 m_webLockRegistry = makeUnique<WebLockRegistryProxy>(*this);
 359 m_sessionID = dataStore.sessionID();
360360}
361361
362362bool WebProcessProxy::isDummyProcessProxy() const
363363{
364  return m_websiteDataStore && processPool().dummyProcessProxy(m_websiteDataStore->sessionID()) == this;
 364 return m_sessionID.isValid() && processPool().dummyProcessProxy(sessionID()) == this;
365365}
366366
367367void WebProcessProxy::updateRegistrationWithDataStore()
368368{
369  if (!m_websiteDataStore)
 369 if (!m_sessionID.isValid())
370370 return;
371 
 371
372372 bool shouldBeRegistered = pageCount() || provisionalPageCount();
373  if (shouldBeRegistered)
374  m_websiteDataStore->registerProcess(*this);
375  else
376  m_websiteDataStore->unregisterProcess(*this);
 373 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(sessionID())) {
 374 if (shouldBeRegistered)
 375 dataStore->registerProcess(*this);
 376 else
 377 dataStore->unregisterProcess(*this);
 378 }
377379}
378380
379381void WebProcessProxy::addProvisionalPageProxy(ProvisionalPageProxy& provisionalPage)

@@void WebProcessProxy::addExistingWebPage(WebPageProxy& webPage, BeginsUsingDataS
596598 ASSERT(!m_pageMap.contains(webPage.identifier()));
597599 ASSERT(!globalPageMap().contains(webPage.identifier()));
598600 RELEASE_ASSERT(!m_isInProcessCache);
599  ASSERT(!m_websiteDataStore || m_websiteDataStore == &webPage.websiteDataStore());
 601 ASSERT(!m_sessionID.isValid() || m_sessionID == webPage.websiteDataStore().sessionID());
600602
601603 if (beginsUsingDataStore == BeginsUsingDataStore::Yes) {
602604 RELEASE_ASSERT(m_processPool);
603  m_processPool->pageBeginUsingWebsiteDataStore(webPage.identifier(), webPage.websiteDataStore());
 605 m_processPool->pageBeginUsingWebsiteDataStore(webPage.identifier(), webPage.websiteDataStore().sessionID());
604606 }
605607
606608 markProcessAsRecentlyUsed();

@@void WebProcessProxy::removeWebPage(WebPageProxy& webPage, EndsUsingDataStore en
632634 ASSERT_UNUSED(removedPage, removedPage == &webPage);
633635
634636 if (endsUsingDataStore == EndsUsingDataStore::Yes)
635  m_processPool->pageEndUsingWebsiteDataStore(webPage.identifier(), webPage.websiteDataStore());
 637 m_processPool->pageEndUsingWebsiteDataStore(webPage.identifier(), webPage.websiteDataStore().sessionID());
636638
637639 removeVisitedLinkStoreUser(webPage.visitedLinkStore(), webPage.identifier());
638640 updateRegistrationWithDataStore();

@@void WebProcessProxy::updateBackForwardItem(const BackForwardListItemState& item
815817
816818void WebProcessProxy::getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&& reply)
817819{
818  websiteDataStore().getNetworkProcessConnection(*this, WTFMove(reply));
 820 if (auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(sessionID()))
 821 dataStore->getNetworkProcessConnection(*this, WTFMove(reply));
819822}
820823
821824#if ENABLE(GPU_PROCESS)

@@void WebProcessProxy::didStartProvisionalLoadForMainFrame(const URL& url)
16941697
16951698 auto registrableDomain = WebCore::RegistrableDomain { url };
16961699 if (m_registrableDomain && *m_registrableDomain != registrableDomain) {
1697  if (isRunningServiceWorkers())
1698  websiteDataStore().networkProcess().terminateRemoteWorkerContextConnectionWhenPossible(RemoteWorkerType::ServiceWorker, websiteDataStore().sessionID(), *m_registrableDomain, coreProcessIdentifier());
1699  if (isRunningSharedWorkers())
1700  websiteDataStore().networkProcess().terminateRemoteWorkerContextConnectionWhenPossible(RemoteWorkerType::SharedWorker, websiteDataStore().sessionID(), *m_registrableDomain, coreProcessIdentifier());
 1700 auto* dataStore = WebsiteDataStore::existingDataStoreForSessionID(sessionID());
 1701 if (dataStore && isRunningServiceWorkers())
 1702 dataStore->networkProcess().terminateRemoteWorkerContextConnectionWhenPossible(RemoteWorkerType::ServiceWorker, sessionID(), *m_registrableDomain, coreProcessIdentifier());
 1703
 1704 if (dataStore && isRunningSharedWorkers())
 1705 dataStore->networkProcess().terminateRemoteWorkerContextConnectionWhenPossible(RemoteWorkerType::SharedWorker, sessionID(), *m_registrableDomain, coreProcessIdentifier());
17011706
17021707 // Null out registrable domain since this process has now been used for several domains.
17031708 m_registrableDomain = WebCore::RegistrableDomain { };

@@WebProcessPool& WebProcessProxy::processPool() const
17441749
17451750PAL::SessionID WebProcessProxy::sessionID() const
17461751{
1747  ASSERT(m_websiteDataStore);
1748  return m_websiteDataStore->sessionID();
 1752 return m_sessionID;
17491753}
17501754
17511755void WebProcessProxy::createSpeechRecognitionServer(SpeechRecognitionServerIdentifier identifier)

Source/WebKit/UIProcess/WebProcessProxy.h

@@public:
167167 void enableRemoteWorkers(RemoteWorkerType, const UserContentControllerIdentifier&);
168168 void disableRemoteWorkers(RemoteWorkerType);
169169
170  WebsiteDataStore& websiteDataStore() const { ASSERT(m_websiteDataStore); return *m_websiteDataStore; }
171170 void setWebsiteDataStore(WebsiteDataStore&);
172171
173172 PAL::SessionID sessionID() const;

@@private:
610609
611610 VisibleWebPageCounter m_visiblePageCounter;
612611
613  RefPtr<WebsiteDataStore> m_websiteDataStore;
 612 PAL::SessionID m_sessionID { 0 };
614613
615614 bool m_isUnderMemoryPressure { false };
616615

Source/WebKit/UIProcess/glib/WebProcessProxyGLib.cpp

@@void WebProcessProxy::platformGetLaunchOptions(ProcessLauncher::LaunchOptions& l
4242 launchOptions.extraInitializationData.set("enable-sandbox"_s, m_processPool->sandboxEnabled() ? "true"_s : "false"_s);
4343
4444 if (m_processPool->sandboxEnabled()) {
45  WebsiteDataStore* dataStore = m_websiteDataStore.get();
46  if (!dataStore) {
47  // Prewarmed processes don't have a WebsiteDataStore yet, so use the primary WebsiteDataStore from the WebProcessPool.
48  // The process won't be used if current WebsiteDataStore is different than the WebProcessPool primary one.
 45 WebsiteDataStore* dataStore = nullptr;
 46 if (m_sessionID.isValid())
 47 dataStore = WebsiteDataStore::existingDataStoreForSessionID(m_sessionID);
 48
 49 // For prewarmed web processes, WebsiteDataStore may not exist yet, so we use default WebsiteDataStore.
 50 if (!dataStore)
4951 dataStore = WebsiteDataStore::defaultDataStore().ptr();
50  }
5152
5253 ASSERT(dataStore);
5354 dataStore->resolveDirectoriesIfNecessary();