/*

* Copyright (C) 2012-2020 Apple Inc. All rights reserved.

* Copyright (C) 2018 Sony Interactive Entertainment Inc.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

* THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "NetworkProcess.h"

#include "ArgumentCoders.h"

#include "Attachment.h"

#include "AuthenticationManager.h"

#include "AuxiliaryProcessMessages.h"

#include "DataReference.h"

#include "Download.h"

#include "DownloadProxyMessages.h"

#if ENABLE(LEGACY_CUSTOM_PROTOCOL_MANAGER)

#include "LegacyCustomProtocolManager.h"

#endif

#include "Logging.h"

#include "NetworkConnectionToWebProcess.h"

#include "NetworkContentRuleListManagerMessages.h"

#include "NetworkLoad.h"

#include "NetworkLoadScheduler.h"

#include "NetworkProcessCreationParameters.h"

#include "NetworkProcessPlatformStrategies.h"

#include "NetworkProcessProxyMessages.h"

#include "NetworkResourceLoader.h"

#include "NetworkSession.h"

#include "NetworkSessionCreationParameters.h"

#include "NetworkStorageManager.h"

#include "PreconnectTask.h"

#include "PrivateClickMeasurementStore.h"

#include "RemoteNetworkingContext.h"

#include "ShouldGrandfatherStatistics.h"

#include "StorageAccessStatus.h"

#include "StorageManagerSet.h"

#include "WebCookieManager.h"

#include "WebIDBServer.h"

#include "WebPageProxyMessages.h"

#include "WebProcessPoolMessages.h"

#include "WebPushMessage.h"

#include "WebResourceLoadStatisticsStore.h"

#include "WebsiteDataFetchOption.h"

#include "WebsiteDataStore.h"

#include "WebsiteDataStoreParameters.h"

#include "WebsiteDataType.h"

#include <WebCore/ClientOrigin.h>

#include <WebCore/CookieJar.h>

#include <WebCore/DNS.h>

#include <WebCore/DeprecatedGlobalSettings.h>

#include <WebCore/DiagnosticLoggingClient.h>

#include <WebCore/HTTPCookieAcceptPolicy.h>

#include <WebCore/LegacySchemeRegistry.h>

#include <WebCore/LogInitialization.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/NetworkStateNotifier.h>

#include <WebCore/NetworkStorageSession.h>

#include <WebCore/ResourceRequest.h>

#include <WebCore/RuntimeApplicationChecks.h>

#include <WebCore/RuntimeEnabledFeatures.h>

#include <WebCore/SWServer.h>

#include <WebCore/SecurityOrigin.h>

#include <WebCore/SecurityOriginData.h>

#include <WebCore/StorageQuotaManager.h>

#include <WebCore/UserContentURLPattern.h>

#include <wtf/Algorithms.h>

#include <wtf/CallbackAggregator.h>

#include <wtf/CryptographicallyRandomNumber.h>

#include <wtf/OptionSet.h>

#include <wtf/ProcessPrivilege.h>

#include <wtf/RunLoop.h>

#include <wtf/UUID.h>

#include <wtf/UniqueRef.h>

#include <wtf/text/AtomString.h>

#if ENABLE(SEC_ITEM_SHIM)

#include "SecItemShim.h"

#endif

#include "NetworkCache.h"

#include "NetworkCacheCoders.h"

#if PLATFORM(COCOA)

#include "LaunchServicesDatabaseObserver.h"

#include "NetworkSessionCocoa.h"

#include <wtf/cocoa/Entitlements.h>

#endif

#if USE(SOUP)

#include "NetworkSessionSoup.h"

#include <WebCore/SoupNetworkSession.h>

#endif

#if USE(CURL)

#include <WebCore/CurlContext.h>

#endif

namespace WebKit {

using namespace WebCore;

static void callExitSoon(IPC::Connection*)

{

// If the connection has been closed and we haven't responded in the main thread for 10 seconds

// the process will exit forcibly.

auto watchdogDelay = 10_s;

WorkQueue::create("com.apple.WebKit.NetworkProcess.WatchDogQueue")->dispatchAfter(watchdogDelay, [] {

// We use _exit here since the watchdog callback is called from another thread and we don't want

// global destructors or atexit handlers to be called from this thread while the main thread is busy

// doing its thing.

RELEASE_LOG_ERROR(IPC, "Exiting process early due to unacknowledged closed-connection");

#if OS(WINDOWS)

// Calling _exit in non-main threads may cause a deadlock in WTF::Thread::ThreadHolder::~ThreadHolder.

TerminateProcess(GetCurrentProcess(), EXIT_FAILURE);

#else

_exit(EXIT_FAILURE);

#endif

});

}

static inline MessagePortChannelRegistry createMessagePortChannelRegistry(NetworkProcess& networkProcess)

{

return MessagePortChannelRegistry { [&networkProcess](auto& messagePortIdentifier, auto processIdentifier, auto&& completionHandler) {

auto* connection = networkProcess.webProcessConnection(processIdentifier);

if (!connection) {

completionHandler(MessagePortChannelProvider::HasActivity::No);

return;

}

connection->checkProcessLocalPortForActivity(messagePortIdentifier, WTFMove(completionHandler));

} };

}

NetworkProcess::NetworkProcess(AuxiliaryProcessInitializationParameters&& parameters)

: m_downloadManager(*this)

#if ENABLE(CONTENT_EXTENSIONS)

, m_networkContentRuleListManager(*this)

#endif

#if PLATFORM(IOS_FAMILY)

, m_webSQLiteDatabaseTracker([this](bool isHoldingLockedFiles) { setIsHoldingLockedFiles(isHoldingLockedFiles); })

#endif

, m_messagePortChannelRegistry(createMessagePortChannelRegistry(*this))

{

NetworkProcessPlatformStrategies::initialize();

addSupplement<AuthenticationManager>();

addSupplement<WebCookieManager>();

#if ENABLE(LEGACY_CUSTOM_PROTOCOL_MANAGER)

addSupplement<LegacyCustomProtocolManager>();

#endif

#if HAVE(LSDATABASECONTEXT)

addSupplement<LaunchServicesDatabaseObserver>();

#endif

#if PLATFORM(COCOA) && ENABLE(LEGACY_CUSTOM_PROTOCOL_MANAGER)

LegacyCustomProtocolManager::networkProcessCreated(*this);

#endif

NetworkStateNotifier::singleton().addListener([weakThis = WeakPtr { *this }](bool isOnLine) {

if (!weakThis)

return;

for (auto& webProcessConnection : weakThis->m_webProcessConnections.values())

webProcessConnection->setOnLineState(isOnLine);

});

initialize(WTFMove(parameters));

}

NetworkProcess::~NetworkProcess() = default;

AuthenticationManager& NetworkProcess::authenticationManager()

{

return *supplement<AuthenticationManager>();

}

DownloadManager& NetworkProcess::downloadManager()

{

return m_downloadManager;

}

void NetworkProcess::removeNetworkConnectionToWebProcess(NetworkConnectionToWebProcess& connection)

{

ASSERT(m_webProcessConnections.contains(connection.webProcessIdentifier()));

m_webProcessConnections.remove(connection.webProcessIdentifier());

}

bool NetworkProcess::shouldTerminate()

{

// Network process keeps session cookies and credentials, so it should never terminate (as long as UI process connection is alive).

return false;

}

void NetworkProcess::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)

{

ASSERT(parentProcessConnection() == &connection);

if (parentProcessConnection() != &connection) {

WTFLogAlways("Ignored message '%s' because it did not come from the UIProcess (destination=%" PRIu64 ")", description(decoder.messageName()), decoder.destinationID());

ASSERT_NOT_REACHED();

return;

}

if (messageReceiverMap().dispatchMessage(connection, decoder))

return;

if (decoder.messageReceiverName() == Messages::AuxiliaryProcess::messageReceiverName()) {

AuxiliaryProcess::didReceiveMessage(connection, decoder);

return;

}

#if ENABLE(CONTENT_EXTENSIONS)

if (decoder.messageReceiverName() == Messages::NetworkContentRuleListManager::messageReceiverName()) {

m_networkContentRuleListManager.didReceiveMessage(connection, decoder);

return;

}

#endif

didReceiveNetworkProcessMessage(connection, decoder);

}

bool NetworkProcess::didReceiveSyncMessage(IPC::Connection& connection, IPC::Decoder& decoder, UniqueRef<IPC::Encoder>& replyEncoder)

{

ASSERT(parentProcessConnection() == &connection);

if (parentProcessConnection() != &connection) {

WTFLogAlways("Ignored message '%s' because it did not come from the UIProcess (destination=%" PRIu64 ")", description(decoder.messageName()), decoder.destinationID());

ASSERT_NOT_REACHED();

return false;

}

if (messageReceiverMap().dispatchSyncMessage(connection, decoder, replyEncoder))

return true;

return didReceiveSyncNetworkProcessMessage(connection, decoder, replyEncoder);

}

void NetworkProcess::didClose(IPC::Connection&)

{

ASSERT(RunLoop::isMain());

auto callbackAggregator = CallbackAggregator::create([this] {

ASSERT(RunLoop::isMain());

stopRunLoop();

});

// Make sure we flush all cookies to disk before exiting.

forEachNetworkSession([&] (auto& session) {

platformFlushCookies(session.sessionID(), [callbackAggregator] { });

// Make sure reference to NetworkProcess in spaceRequester is removed.

session.closeIDBServer([callbackAggregator] { });

});

}

void NetworkProcess::didCreateDownload()

{

disableTermination();

}

void NetworkProcess::didDestroyDownload()

{

enableTermination();

}

IPC::Connection* NetworkProcess::downloadProxyConnection()

{

return parentProcessConnection();

}

AuthenticationManager& NetworkProcess::downloadsAuthenticationManager()

{

return authenticationManager();

}

void NetworkProcess::lowMemoryHandler(Critical critical)

{

if (m_suppressMemoryPressureHandler)

return;

WTF::releaseFastMallocFreeMemory();

forEachNetworkSession([critical](auto& session) {

session.lowMemoryHandler(critical);

});

}

void NetworkProcess::initializeNetworkProcess(NetworkProcessCreationParameters&& parameters)

{

applyProcessCreationParameters(parameters.auxiliaryProcessParameters);

#if HAVE(SEC_KEY_PROXY)

WTF::setProcessPrivileges({ ProcessPrivilege::CanAccessRawCookies });

#else

WTF::setProcessPrivileges({ ProcessPrivilege::CanAccessRawCookies, ProcessPrivilege::CanAccessCredentials });

#endif

WebCore::NetworkStorageSession::permitProcessToUseCookieAPI(true);

platformInitializeNetworkProcess(parameters);

WTF::Thread::setCurrentThreadIsUserInitiated();

AtomString::init();

m_suppressMemoryPressureHandler = parameters.shouldSuppressMemoryPressureHandler;

if (!m_suppressMemoryPressureHandler) {

auto& memoryPressureHandler = MemoryPressureHandler::singleton();

memoryPressureHandler.setLowMemoryHandler([this] (Critical critical, Synchronous) {

lowMemoryHandler(critical);

});

memoryPressureHandler.install();

}

setCacheModel(parameters.cacheModel);

setPrivateClickMeasurementEnabled(parameters.enablePrivateClickMeasurement);

m_ftpEnabled = parameters.ftpEnabled;

for (auto& supplement : m_supplements.values())

supplement->initialize(parameters);

for (auto& scheme : parameters.urlSchemesRegisteredAsSecure)

registerURLSchemeAsSecure(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsBypassingContentSecurityPolicy)

registerURLSchemeAsBypassingContentSecurityPolicy(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsLocal)

registerURLSchemeAsLocal(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsNoAccess)

registerURLSchemeAsNoAccess(scheme);

for (auto&& websiteDataStoreParameters : WTFMove(parameters.websiteDataStoreParameters))

addWebsiteDataStore(WTFMove(websiteDataStoreParameters));

RELEASE_LOG(Process, "%p - NetworkProcess::initializeNetworkProcess: Presenting processPID=%d", this, WebCore::presentingApplicationPID());

}

void NetworkProcess::initializeConnection(IPC::Connection* connection)

{

AuxiliaryProcess::initializeConnection(connection);

// We give a chance for didClose() to get called on the main thread but forcefully call _exit() after a delay

// in case the main thread is unresponsive or didClose() takes too long.

connection->setDidCloseOnConnectionWorkQueueCallback(callExitSoon);

for (auto& supplement : m_supplements.values())

supplement->initializeConnection(connection);

}

void NetworkProcess::createNetworkConnectionToWebProcess(ProcessIdentifier identifier, PAL::SessionID sessionID, CompletionHandler<void(std::optional<IPC::Attachment>&&, HTTPCookieAcceptPolicy)>&& completionHandler)

{

auto ipcConnection = createIPCConnectionPair();

if (!ipcConnection) {

completionHandler({ }, HTTPCookieAcceptPolicy::Never);

return;

}

auto newConnection = NetworkConnectionToWebProcess::create(*this, identifier, sessionID, ipcConnection->first);

auto& connection = newConnection.get();

ASSERT(!m_webProcessConnections.contains(identifier));

m_webProcessConnections.add(identifier, WTFMove(newConnection));

auto* storage = storageSession(sessionID);

completionHandler(WTFMove(ipcConnection->second), storage ? storage->cookieAcceptPolicy() : HTTPCookieAcceptPolicy::Never);

connection.setOnLineState(NetworkStateNotifier::singleton().onLine());

if (auto* session = networkSession(sessionID)) {

session->ensureWebIDBServer().addConnection(connection.connection(), identifier);

if (auto* manager = session->storageManager())

manager->startReceivingMessageFromConnection(connection.connection());

}

}

void NetworkProcess::clearCachedCredentials(PAL::SessionID sessionID)

{

if (auto* session = networkSession(sessionID)) {

if (auto* storageSession = session->networkStorageSession())

storageSession->credentialStorage().clearCredentials();

session->clearCredentials();

}

}

void NetworkProcess::addWebsiteDataStore(WebsiteDataStoreParameters&& parameters)

{

auto sessionID = parameters.networkSessionParameters.sessionID;

RemoteNetworkingContext::ensureWebsiteDataStoreSession(*this, parameters);

addSessionStorageQuotaManager(sessionID, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota, parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);

if (auto* session = networkSession(sessionID)) {

session->addStorageManagerSession(parameters.generalStorageDirectory, parameters.generalStorageDirectoryHandle, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle);

session->addIndexedDatabaseSession(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);

#if ENABLE(SERVICE_WORKER)

session->addServiceWorkerSession(parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);

#endif

}

}

void NetworkProcess::addSessionStorageQuotaManager(PAL::SessionID sessionID, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota, const String& cacheRootPath, SandboxExtension::Handle& cacheRootPathHandle)

{

Locker locker { m_sessionStorageQuotaManagersLock };

auto isNewEntry = m_sessionStorageQuotaManagers.ensure(sessionID, [defaultQuota, defaultThirdPartyQuota, &cacheRootPath] {

return makeUnique<SessionStorageQuotaManager>(cacheRootPath, defaultQuota, defaultThirdPartyQuota);

}).isNewEntry;

if (isNewEntry)

SandboxExtension::consumePermanently(cacheRootPathHandle);

else

ASSERT_NOT_REACHED();

}

void NetworkProcess::removeSessionStorageQuotaManager(PAL::SessionID sessionID)

{

Locker locker { m_sessionStorageQuotaManagersLock };

ASSERT(m_sessionStorageQuotaManagers.contains(sessionID));

m_sessionStorageQuotaManagers.remove(sessionID);

}

void NetworkProcess::forEachNetworkSession(const Function<void(NetworkSession&)>& functor)

{

for (auto& session : m_networkSessions.values())

functor(*session);

}

std::unique_ptr<WebCore::NetworkStorageSession> NetworkProcess::newTestingSession(PAL::SessionID sessionID)

{

#if PLATFORM(COCOA)

// Session name should be short enough for shared memory region name to be under the limit, otherwise sandbox rules won't work (see <rdar://problem/13642852>).

auto session = WebCore::createPrivateStorageSession(makeString("WebKit Test-", getCurrentProcessID()).createCFString().get(), std::nullopt, NetworkStorageSession::ShouldDisableCFURLCache::Yes);

RetainPtr<CFHTTPCookieStorageRef> cookieStorage;

if (WebCore::NetworkStorageSession::processMayUseCookieAPI()) {

ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));

if (session)

cookieStorage = adoptCF(_CFURLStorageSessionCopyCookieStorage(kCFAllocatorDefault, session.get()));

}

return makeUnique<WebCore::NetworkStorageSession>(sessionID, WTFMove(session), WTFMove(cookieStorage));

#elif USE(CURL) || USE(SOUP)

return makeUnique<WebCore::NetworkStorageSession>(sessionID);

#endif

}

#if PLATFORM(COCOA)

void NetworkProcess::ensureSession(PAL::SessionID sessionID, bool shouldUseTestingNetworkSession, const String& identifierBase, RetainPtr<CFHTTPCookieStorageRef>&& cookieStorage)

#else

void NetworkProcess::ensureSession(PAL::SessionID sessionID, bool shouldUseTestingNetworkSession, const String& identifierBase)

#endif

{

auto addResult = m_networkStorageSessions.add(sessionID, nullptr);

if (!addResult.isNewEntry)

return;

if (shouldUseTestingNetworkSession) {

addResult.iterator->value = newTestingSession(sessionID);

return;

}

#if PLATFORM(COCOA)

RetainPtr<CFURLStorageSessionRef> storageSession;

RetainPtr<CFStringRef> cfIdentifier = makeString(identifierBase, ".PrivateBrowsing.", createCanonicalUUIDString()).createCFString();

if (sessionID.isEphemeral())

storageSession = createPrivateStorageSession(cfIdentifier.get(), std::nullopt, WebCore::NetworkStorageSession::ShouldDisableCFURLCache::Yes);

else if (sessionID != PAL::SessionID::defaultSessionID())

storageSession = WebCore::NetworkStorageSession::createCFStorageSessionForIdentifier(cfIdentifier.get());

if (NetworkStorageSession::processMayUseCookieAPI()) {

ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));

if (!cookieStorage && storageSession)

cookieStorage = adoptCF(_CFURLStorageSessionCopyCookieStorage(kCFAllocatorDefault, storageSession.get()));

}

addResult.iterator->value = makeUnique<NetworkStorageSession>(sessionID, WTFMove(storageSession), WTFMove(cookieStorage));

#elif USE(CURL) || USE(SOUP)

addResult.iterator->value = makeUnique<NetworkStorageSession>(sessionID);

#endif

}

void NetworkProcess::cookieAcceptPolicyChanged(HTTPCookieAcceptPolicy newPolicy)

{

for (auto& connection : m_webProcessConnections.values())

connection->cookieAcceptPolicyChanged(newPolicy);

}

WebCore::NetworkStorageSession* NetworkProcess::storageSession(PAL::SessionID sessionID) const

{

return m_networkStorageSessions.get(sessionID);

}

void NetworkProcess::forEachNetworkStorageSession(const Function<void(WebCore::NetworkStorageSession&)>& functor)

{

for (auto& storageSession : m_networkStorageSessions.values())

functor(*storageSession);

}

NetworkSession* NetworkProcess::networkSession(PAL::SessionID sessionID) const

{

ASSERT(RunLoop::isMain());

return m_networkSessions.get(sessionID);

}

void NetworkProcess::setSession(PAL::SessionID sessionID, std::unique_ptr<NetworkSession>&& session)

{

ASSERT(RunLoop::isMain());

m_networkSessions.set(sessionID, WTFMove(session));

}

void NetworkProcess::destroySession(PAL::SessionID sessionID)

{

ASSERT(RunLoop::isMain());

#if !USE(SOUP) && !USE(CURL)

// cURL and Soup based ports destroy the default session right before the process exits to avoid leaking

// network resources like the cookies database.

ASSERT(sessionID != PAL::SessionID::defaultSessionID());

#endif

if (auto session = m_networkSessions.take(sessionID))

session->invalidateAndCancel();

m_networkStorageSessions.remove(sessionID);

m_sessionsControlledByAutomation.remove(sessionID);

}

#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)

void NetworkProcess::dumpResourceLoadStatistics(PAL::SessionID sessionID, CompletionHandler<void(String)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->dumpResourceLoadStatistics(WTFMove(completionHandler));

else

completionHandler({ });

} else {

ASSERT_NOT_REACHED();

completionHandler({ });

}

}

void NetworkProcess::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, const Vector<RegistrableDomain>& domainsToBlock, CompletionHandler<void()>&& completionHandler)

{

if (auto* networkStorageSession = storageSession(sessionID))

networkStorageSession->setPrevalentDomainsToBlockAndDeleteCookiesFor(domainsToBlock);

completionHandler();

}

void NetworkProcess::isGrandfathered(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->isGrandfathered(domain, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::isPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->isPrevalentResource(domain, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::isVeryPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->isVeryPrevalentResource(domain, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::setAgeCapForClientSideCookies(PAL::SessionID sessionID, std::optional<Seconds> seconds, CompletionHandler<void()>&& completionHandler)

{

if (auto* networkStorageSession = storageSession(sessionID))

networkStorageSession->setAgeCapForClientSideCookies(seconds);

completionHandler();

}

void NetworkProcess::setGrandfathered(PAL::SessionID sessionID, const RegistrableDomain& domain, bool isGrandfathered, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setGrandfathered(domain, isGrandfathered, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setPrevalentResource(domain, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setPrevalentResourceForDebugMode(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setPrevalentResourceForDebugMode(domain, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setVeryPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setVeryPrevalentResource(domain, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::clearPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->clearPrevalentResource(domain, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::scheduleCookieBlockingUpdate(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->scheduleCookieBlockingUpdate(WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::scheduleClearInMemoryAndPersistent(PAL::SessionID sessionID, std::optional<WallTime> modifiedSince, ShouldGrandfatherStatistics shouldGrandfather, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

session->clearIsolatedSessions();

if (auto* resourceLoadStatistics = session->resourceLoadStatistics()) {

if (modifiedSince)

resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince.value(), shouldGrandfather, WTFMove(completionHandler));

else

resourceLoadStatistics->scheduleClearInMemoryAndPersistent(shouldGrandfather, WTFMove(completionHandler));

} else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::getResourceLoadStatisticsDataSummary(PAL::SessionID sessionID, CompletionHandler<void(Vector<WebResourceLoadStatisticsStore::ThirdPartyData>&&)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->aggregatedThirdPartyData(WTFMove(completionHandler));

else

completionHandler({ });

} else {

ASSERT_NOT_REACHED();

completionHandler({ });

}

}

void NetworkProcess::resetParametersToDefaultValues(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

session->resetCNAMEDomainData();

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->resetParametersToDefaultValues(WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::scheduleStatisticsAndDataRecordsProcessing(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->scheduleStatisticsAndDataRecordsProcessing(WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::statisticsDatabaseHasAllTables(PAL::SessionID sessionID, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->statisticsDatabaseHasAllTables(WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::setNotifyPagesWhenDataRecordsWereScanned(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setNotifyPagesWhenDataRecordsWereScanned(value, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setIsRunningResourceLoadStatisticsTest(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setIsRunningTest(value, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setSubframeUnderTopFrameDomain(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setSubframeUnderTopFrameDomain(subFrameDomain, topFrameDomain, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::isRegisteredAsRedirectingTo(PAL::SessionID sessionID, const RegistrableDomain& domainRedirectedFrom, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->isRegisteredAsRedirectingTo(domainRedirectedFrom, domainRedirectedTo, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->isRegisteredAsSubFrameUnder(subFrameDomain, topFrameDomain, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::setSubresourceUnderTopFrameDomain(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setSubresourceUnderTopFrameDomain(subresourceDomain, topFrameDomain, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setSubresourceUniqueRedirectTo(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setSubresourceUniqueRedirectTo(subresourceDomain, domainRedirectedTo, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& domainRedirectedFrom, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setSubresourceUniqueRedirectFrom(subresourceDomain, domainRedirectedFrom, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::isRegisteredAsSubresourceUnder(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->isRegisteredAsSubresourceUnder(subresourceDomain, topFrameDomain, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID, const RegistrableDomain& topFrameDomain, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setTopFrameUniqueRedirectTo(topFrameDomain, domainRedirectedTo, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, const RegistrableDomain& topFrameDomain, const RegistrableDomain& domainRedirectedFrom, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setTopFrameUniqueRedirectFrom(topFrameDomain, domainRedirectedFrom, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::setLastSeen(PAL::SessionID sessionID, const RegistrableDomain& domain, Seconds seconds, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->setLastSeen(domain, seconds, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::domainIDExistsInDatabase(PAL::SessionID sessionID, int domainID, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->domainIDExistsInDatabase(domainID, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::mergeStatisticForTesting(PAL::SessionID sessionID, const RegistrableDomain& domain, const RegistrableDomain& topFrameDomain1, const RegistrableDomain& topFrameDomain2, Seconds lastSeen, bool hadUserInteraction, Seconds mostRecentUserInteraction, bool isGrandfathered, bool isPrevalent, bool isVeryPrevalent, unsigned dataRecordsRemoved, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->mergeStatisticForTesting(domain, topFrameDomain1, topFrameDomain2, lastSeen, hadUserInteraction, mostRecentUserInteraction, isGrandfathered, isPrevalent, isVeryPrevalent, dataRecordsRemoved, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::insertExpiredStatisticForTesting(PAL::SessionID sessionID, const RegistrableDomain& domain, unsigned numberOfOperatingDaysPassed, bool hadUserInteraction, bool isScheduledForAllButCookieDataRemoval, bool isPrevalent, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->insertExpiredStatisticForTesting(domain, numberOfOperatingDaysPassed, hadUserInteraction, isScheduledForAllButCookieDataRemoval, isPrevalent, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::getAllStorageAccessEntries(PAL::SessionID sessionID, CompletionHandler<void(Vector<String> domains)>&& completionHandler)

{

if (auto* networkStorageSession = storageSession(sessionID))

completionHandler(networkStorageSession->getAllStorageAccessEntries());

else {

ASSERT_NOT_REACHED();

completionHandler({ });

}

}

void NetworkProcess::logFrameNavigation(PAL::SessionID sessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, const RegistrableDomain& sourceDomain, bool isRedirect, bool isMainFrame, Seconds delayAfterMainFrameDocumentLoad, bool wasPotentiallyInitiatedByUser)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->logFrameNavigation(targetDomain, topFrameDomain, sourceDomain, isRedirect, isMainFrame, delayAfterMainFrameDocumentLoad, wasPotentiallyInitiatedByUser);

} else

ASSERT_NOT_REACHED();

}

void NetworkProcess::logUserInteraction(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->logUserInteraction(domain, WTFMove(completionHandler));

else

completionHandler();

} else {

ASSERT_NOT_REACHED();

completionHandler();

}

}

void NetworkProcess::hadUserInteraction(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->hasHadUserInteraction(domain, WTFMove(completionHandler));

else

completionHandler(false);

} else {

ASSERT_NOT_REACHED();

completionHandler(false);

}

}

void NetworkProcess::isRelationshipOnlyInDatabaseOnce(PAL::SessionID sessionID, const RegistrableDomain& subDomain, const RegistrableDomain& topDomain, CompletionHandler<void(bool)>&& completionHandler)

{

if (auto* session = networkSession(sessionID)) {

if (auto* resourceLoadStatistics = session->resourceLoadStatistics())

resourceLoadStatistics->isRelationshipOnlyInDatabaseOnce(subDomain, topDomain, WTFMove(completionHandler));

else

completionHandler(false);