void WebProcess::platformSetCacheModel(CacheModel cacheModel)
{
unsigned cacheTotalCapacity = 0;
unsigned cacheMinDeadCapacity = 0;
unsigned cacheMaxDeadCapacity = 0;
double deadDecodedDataDeletionInterval = 0;
unsigned pageCacheCapacity = 0;
unsigned long urlCacheMemoryCapacity = 0;
unsigned long urlCacheDiskCapacity = 0;
uint64_t diskFreeSize = 0;
SoupCache* cache = nullptr;
if (!usesNetworkProcess()) {
cache = SOUP_CACHE(soup_session_get_feature(WebCore::ResourceHandle::defaultSession(), SOUP_TYPE_CACHE));
diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024;
}
uint64_t memSize = getMemorySize();
calculateCacheSizes(cacheModel, memSize, diskFreeSize,
cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
WebCore::memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
WebCore::memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
WebCore::pageCache()->setCapacity(pageCacheCapacity);
if (!usesNetworkProcess()) {
if (urlCacheDiskCapacity > soup_cache_get_max_size(cache))
soup_cache_set_max_size(cache, urlCacheDiskCapacity);
}
}
void WebProcess::platformSetCacheModel(CacheModel cacheModel)
{
unsigned cacheTotalCapacity = 0;
unsigned cacheMinDeadCapacity = 0;
unsigned cacheMaxDeadCapacity = 0;
auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 };
unsigned pageCacheCapacity = 0;
unsigned long urlCacheMemoryCapacity = 0;
unsigned long urlCacheDiskCapacity = 0;
uint64_t diskFreeSize = 0;
SoupCache* cache = nullptr;
if (!usesNetworkProcess()) {
cache = WebCore::SoupNetworkSession::defaultSession().cache();
diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024;
}
uint64_t memSize = getMemorySize();
calculateCacheSizes(cacheModel, memSize, diskFreeSize,
cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
WebCore::memoryCache()->setDisabled(cacheModel == CacheModelDocumentViewer);
WebCore::memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
WebCore::memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
WebCore::pageCache()->setCapacity(pageCacheCapacity);
if (!usesNetworkProcess()) {
if (urlCacheDiskCapacity > soup_cache_get_max_size(cache))
soup_cache_set_max_size(cache, urlCacheDiskCapacity);
}
}
void WebProcess::platformInitializeWebProcess(const WebProcessCreationParameters& parameters, IPC::MessageDecoder&)
{
#if ENABLE(SECCOMP_FILTERS)
{
#if PLATFORM(EFL)
SeccompFiltersWebProcessEfl seccompFilters(parameters);
#endif
seccompFilters.initialize();
}
#endif
if (usesNetworkProcess())
return;
ASSERT(!parameters.diskCacheDirectory.isEmpty());
GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(parameters.diskCacheDirectory.utf8().data(), SOUP_CACHE_SINGLE_USER));
soup_session_add_feature(WebCore::ResourceHandle::defaultSession(), SOUP_SESSION_FEATURE(soupCache.get()));
soup_cache_load(soupCache.get());
if (!parameters.cookiePersistentStoragePath.isEmpty()) {
supplement<WebCookieManager>()->setCookiePersistentStorage(parameters.cookiePersistentStoragePath,
parameters.cookiePersistentStorageType);
}
supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy);
if (!parameters.languages.isEmpty())
setSoupSessionAcceptLanguage(parameters.languages);
for (size_t i = 0; i < parameters.urlSchemesRegistered.size(); i++)
supplement<WebSoupRequestManager>()->registerURIScheme(parameters.urlSchemesRegistered[i]);
setIgnoreTLSErrors(parameters.ignoreTLSErrors);
WebCore::addLanguageChangeObserver(this, languageChanged);
}
DownloadManager& WebProcess::downloadManager()
{
ASSERT(!usesNetworkProcess());
static NeverDestroyed<DownloadManager> downloadManager(this);
return downloadManager;
}
void WebContext::setIgnoreTLSErrors(bool ignoreTLSErrors)
{
m_ignoreTLSErrors = ignoreTLSErrors;
#if ENABLE(NETWORK_PROCESS)
if (usesNetworkProcess() && networkProcess()) {
networkProcess()->send(Messages::NetworkProcess::SetIgnoreTLSErrors(m_ignoreTLSErrors), 0);
return;
}
#endif
sendToAllProcesses(Messages::WebProcess::SetIgnoreTLSErrors(m_ignoreTLSErrors));
}
void WebProcess::platformClearResourceCaches(ResourceCachesToClear cachesToClear)
{
if (cachesToClear == InMemoryResourceCachesOnly)
return;
// If we're using the network process then it is the only one that needs to clear the disk cache.
if (usesNetworkProcess())
return;
soup_cache_clear(WebCore::SoupNetworkSession::defaultSession().cache());
}
void WebProcess::platformClearResourceCaches(ResourceCachesToClear cachesToClear)
{
if (cachesToClear == InMemoryResourceCachesOnly)
return;
// If we're using the network process then it is the only one that needs to clear the disk cache.
if (usesNetworkProcess())
return;
soup_cache_clear(SOUP_CACHE(soup_session_get_feature(WebCore::ResourceHandle::defaultSession(), SOUP_TYPE_CACHE)));
}
DownloadProxy* WebContext::createDownloadProxy()
{
#if ENABLE(NETWORK_PROCESS)
if (usesNetworkProcess()) {
ensureNetworkProcess();
ASSERT(m_networkProcess);
return m_networkProcess->createDownloadProxy();
}
#endif
return ensureSharedWebProcess().createDownloadProxy();
}
void WebProcess::platformSetCacheModel(CacheModel cacheModel)
{
unsigned cacheTotalCapacity = 0;
unsigned cacheMinDeadCapacity = 0;
unsigned cacheMaxDeadCapacity = 0;
auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 };
unsigned pageCacheSize = 0;
unsigned long urlCacheMemoryCapacity = 0;
unsigned long urlCacheDiskCapacity = 0;
uint64_t diskFreeSize = 0;
SoupCache* cache = nullptr;
if (!usesNetworkProcess()) {
cache = WebCore::SoupNetworkSession::defaultSession().cache();
diskFreeSize = getCacheDiskFreeSize(cache) / WTF::MB;
}
uint64_t memSize = WTF::ramSize() / WTF::MB;
calculateCacheSizes(cacheModel, memSize, diskFreeSize,
cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
pageCacheSize, urlCacheMemoryCapacity, urlCacheDiskCapacity);
auto& memoryCache = WebCore::MemoryCache::singleton();
memoryCache.setDisabled(cacheModel == CacheModelDocumentViewer);
memoryCache.setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
memoryCache.setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
WebCore::PageCache::singleton().setMaxSize(pageCacheSize);
#if PLATFORM(GTK)
WebCore::PageCache::singleton().setShouldClearBackingStores(true);
#endif
if (!usesNetworkProcess()) {
if (urlCacheDiskCapacity > soup_cache_get_max_size(cache))
soup_cache_set_max_size(cache, urlCacheDiskCapacity);
}
}
bool WebProcess::shouldTerminate()
{
ASSERT(m_pageMap.isEmpty());
ASSERT(usesNetworkProcess() || !downloadManager().isDownloading());
// FIXME: the ShouldTerminate message should also send termination parameters, such as any session cookies that need to be preserved.
bool shouldTerminate = false;
if (parentProcessConnection()->sendSync(Messages::WebProcessProxy::ShouldTerminate(), Messages::WebProcessProxy::ShouldTerminate::Reply(shouldTerminate), 0)
&& !shouldTerminate)
return false;
return true;
}
void WebProcess::platformInitializeWebProcess(WebProcessCreationParameters&& parameters)
{
#if ENABLE(SECCOMP_FILTERS)
{
#if PLATFORM(EFL)
SeccompFiltersWebProcessEfl seccompFilters(parameters);
#elif PLATFORM(GTK)
SeccompFiltersWebProcessGtk seccompFilters(parameters);
#endif
seccompFilters.initialize();
}
#endif
if (usesNetworkProcess())
return;
ASSERT(!parameters.diskCacheDirectory.isEmpty());
// We used to use the given cache directory for the soup cache, but now we use a subdirectory to avoid
// conflicts with other cache files in the same directory. Remove the old cache files if they still exist.
WebCore::SoupNetworkSession::defaultSession().clearCache(WebCore::directoryName(parameters.diskCacheDirectory));
#if ENABLE(NETWORK_CACHE)
// When network cache is enabled, the disk cache directory is the network process one.
CString diskCachePath = WebCore::pathByAppendingComponent(WebCore::directoryName(parameters.diskCacheDirectory), "webkit").utf8();
#else
CString diskCachePath = parameters.diskCacheDirectory.utf8();
#endif
GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(diskCachePath.data(), SOUP_CACHE_SINGLE_USER));
WebCore::SoupNetworkSession::defaultSession().setCache(soupCache.get());
// Set an initial huge max_size for the SoupCache so the call to soup_cache_load() won't evict any cached
// resource. The final size of the cache will be set by NetworkProcess::platformSetCacheModel().
unsigned initialMaxSize = soup_cache_get_max_size(soupCache.get());
soup_cache_set_max_size(soupCache.get(), G_MAXUINT);
soup_cache_load(soupCache.get());
soup_cache_set_max_size(soupCache.get(), initialMaxSize);
if (!parameters.cookiePersistentStoragePath.isEmpty()) {
supplement<WebCookieManager>()->setCookiePersistentStorage(parameters.cookiePersistentStoragePath,
parameters.cookiePersistentStorageType);
}
supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy);
if (!parameters.languages.isEmpty())
setSoupSessionAcceptLanguage(parameters.languages);
setIgnoreTLSErrors(parameters.ignoreTLSErrors);
WebCore::addLanguageChangeObserver(this, languageChanged);
}
DownloadProxy* WebContext::download(WebPageProxy* initiatingPage, const ResourceRequest& request)
{
DownloadProxy* downloadProxy = createDownloadProxy();
uint64_t initiatingPageID = initiatingPage ? initiatingPage->pageID() : 0;
#if ENABLE(NETWORK_PROCESS)
if (usesNetworkProcess() && networkProcess()) {
// FIXME (NetworkProcess): Replicate whatever FrameLoader::setOriginalURLForDownloadRequest does with the request here.
networkProcess()->send(Messages::NetworkProcess::DownloadRequest(downloadProxy->downloadID(), request), 0);
return downloadProxy;
}
#endif
m_processes[0]->send(Messages::WebProcess::DownloadRequest(downloadProxy->downloadID(), initiatingPageID, request), 0);
return downloadProxy;
}
void WebContext::platformInitializeWebProcess(WebProcessCreationParameters& parameters)
{
initInspectorServer();
if (!parameters.urlSchemesRegisteredAsLocal.contains("resource")) {
WebCore::SchemeRegistry::registerURLSchemeAsLocal("resource");
parameters.urlSchemesRegisteredAsLocal.append("resource");
}
if (!usesNetworkProcess()) {
parameters.urlSchemesRegisteredForCustomProtocols = supplement<WebSoupCustomProtocolRequestManager>()->registeredSchemesForCustomProtocols();
supplement<WebCookieManagerProxy>()->getCookiePersistentStorage(parameters.cookiePersistentStoragePath, parameters.cookiePersistentStorageType);
parameters.cookieAcceptPolicy = m_initialHTTPCookieAcceptPolicy;
parameters.ignoreTLSErrors = m_ignoreTLSErrors;
}
}
void WebContext::setAnyPageGroupMightHavePrivateBrowsingEnabled(bool privateBrowsingEnabled)
{
m_iconDatabase->setPrivateBrowsingEnabled(privateBrowsingEnabled);
#if ENABLE(NETWORK_PROCESS)
if (usesNetworkProcess() && networkProcess()) {
if (privateBrowsingEnabled)
networkProcess()->send(Messages::NetworkProcess::EnsurePrivateBrowsingSession(SessionID::legacyPrivateSessionID()), 0);
else
networkProcess()->send(Messages::NetworkProcess::DestroyPrivateBrowsingSession(SessionID::legacyPrivateSessionID()), 0);
}
#endif // ENABLED(NETWORK_PROCESS)
if (privateBrowsingEnabled)
sendToAllProcesses(Messages::WebProcess::EnsurePrivateBrowsingSession(SessionID::legacyPrivateSessionID()));
else
sendToAllProcesses(Messages::WebProcess::DestroyPrivateBrowsingSession(SessionID::legacyPrivateSessionID()));
}
void WebContext::platformInitializeWebProcess(WebProcessCreationParameters& parameters)
{
initInspectorServer();
if (!parameters.urlSchemesRegisteredAsLocal.contains("resource")) {
WebCore::SchemeRegistry::registerURLSchemeAsLocal("resource");
parameters.urlSchemesRegisteredAsLocal.append("resource");
}
if (!usesNetworkProcess()) {
#if ENABLE(CUSTOM_PROTOCOLS)
parameters.urlSchemesRegisteredForCustomProtocols = supplement<WebSoupCustomProtocolRequestManager>()->registeredSchemesForCustomProtocols();
#else
parameters.urlSchemesRegistered = supplement<WebSoupRequestManagerProxy>()->registeredURISchemes();
#endif
supplement<WebCookieManagerProxy>()->getCookiePersistentStorage(parameters.cookiePersistentStoragePath, parameters.cookiePersistentStorageType);
parameters.cookieAcceptPolicy = m_initialHTTPCookieAcceptPolicy;
parameters.ignoreTLSErrors = m_ignoreTLSErrors;
}
parameters.shouldTrackVisitedLinks = true;
}
void WebProcess::initializeWebProcess(const WebProcessCreationParameters& parameters, CoreIPC::MessageDecoder& decoder)
{
ASSERT(m_pageMap.isEmpty());
platformInitializeWebProcess(parameters, decoder);
memoryPressureHandler().install();
RefPtr<APIObject> injectedBundleInitializationUserData;
InjectedBundleUserMessageDecoder messageDecoder(injectedBundleInitializationUserData);
if (!decoder.decode(messageDecoder))
return;
if (!parameters.injectedBundlePath.isEmpty()) {
m_injectedBundle = InjectedBundle::create(parameters.injectedBundlePath);
m_injectedBundle->setSandboxExtension(SandboxExtension::create(parameters.injectedBundlePathExtensionHandle));
if (!m_injectedBundle->load(injectedBundleInitializationUserData.get())) {
// Don't keep around the InjectedBundle reference if the load fails.
m_injectedBundle.clear();
}
}
WebProcessSupplementMap::const_iterator it = m_supplements.begin();
WebProcessSupplementMap::const_iterator end = m_supplements.end();
for (; it != end; ++it)
it->value->initialize(parameters);
#if ENABLE(ICONDATABASE)
m_iconDatabaseProxy->setEnabled(parameters.iconDatabaseEnabled);
#endif
if (!parameters.applicationCacheDirectory.isEmpty())
cacheStorage().setCacheDirectory(parameters.applicationCacheDirectory);
setShouldTrackVisitedLinks(parameters.shouldTrackVisitedLinks);
setCacheModel(static_cast<uint32_t>(parameters.cacheModel));
if (!parameters.languages.isEmpty())
overrideUserPreferredLanguages(parameters.languages);
m_textCheckerState = parameters.textCheckerState;
m_fullKeyboardAccessEnabled = parameters.fullKeyboardAccessEnabled;
for (size_t i = 0; i < parameters.urlSchemesRegistererdAsEmptyDocument.size(); ++i)
registerURLSchemeAsEmptyDocument(parameters.urlSchemesRegistererdAsEmptyDocument[i]);
for (size_t i = 0; i < parameters.urlSchemesRegisteredAsSecure.size(); ++i)
registerURLSchemeAsSecure(parameters.urlSchemesRegisteredAsSecure[i]);
for (size_t i = 0; i < parameters.urlSchemesForWhichDomainRelaxationIsForbidden.size(); ++i)
setDomainRelaxationForbiddenForURLScheme(parameters.urlSchemesForWhichDomainRelaxationIsForbidden[i]);
for (size_t i = 0; i < parameters.urlSchemesRegisteredAsLocal.size(); ++i)
registerURLSchemeAsLocal(parameters.urlSchemesRegisteredAsLocal[i]);
for (size_t i = 0; i < parameters.urlSchemesRegisteredAsNoAccess.size(); ++i)
registerURLSchemeAsNoAccess(parameters.urlSchemesRegisteredAsNoAccess[i]);
for (size_t i = 0; i < parameters.urlSchemesRegisteredAsDisplayIsolated.size(); ++i)
registerURLSchemeAsDisplayIsolated(parameters.urlSchemesRegisteredAsDisplayIsolated[i]);
for (size_t i = 0; i < parameters.urlSchemesRegisteredAsCORSEnabled.size(); ++i)
registerURLSchemeAsCORSEnabled(parameters.urlSchemesRegisteredAsCORSEnabled[i]);
setDefaultRequestTimeoutInterval(parameters.defaultRequestTimeoutInterval);
if (parameters.shouldAlwaysUseComplexTextCodePath)
setAlwaysUsesComplexTextCodePath(true);
if (parameters.shouldUseFontSmoothing)
setShouldUseFontSmoothing(true);
#if PLATFORM(MAC) || USE(CFNETWORK)
WebFrameNetworkingContext::setPrivateBrowsingStorageSessionIdentifierBase(parameters.uiProcessBundleIdentifier);
#endif
if (parameters.shouldUseTestingNetworkSession)
NetworkStorageSession::switchToNewTestingSession();
#if ENABLE(NETWORK_PROCESS)
m_usesNetworkProcess = parameters.usesNetworkProcess;
ensureNetworkProcessConnection();
if (usesNetworkProcess())
CookieStorageShim::shared().initialize();
#endif
setTerminationTimeout(parameters.terminationTimeout);
resetPlugInAutoStartOriginHashes(parameters.plugInAutoStartOriginHashes);
for (size_t i = 0; i < parameters.plugInAutoStartOrigins.size(); ++i)
m_plugInAutoStartOrigins.add(parameters.plugInAutoStartOrigins[i]);
}
void WebProcess::allowSpecificHTTPSCertificateForHost(const WebCore::CertificateInfo& certificateInfo, const String& host)
{
ASSERT(!usesNetworkProcess());
WebCore::ResourceHandle::setClientCertificate(host, certificateInfo.certificate());
}
void WebProcess::setIgnoreTLSErrors(bool ignoreTLSErrors)
{
ASSERT(!usesNetworkProcess());
WebCore::ResourceHandle::setIgnoreSSLErrors(ignoreTLSErrors);
}
void WebProcess::platformTerminate()
{
if (!usesNetworkProcess())
WebCore::removeLanguageChangeObserver(this);
}
void WebProcess::initializeWebProcess(WebProcessCreationParameters&& parameters)
{
ASSERT(m_pageMap.isEmpty());
#if ENABLE(NETWORK_PROCESS)
m_usesNetworkProcess = parameters.usesNetworkProcess;
#endif
#if OS(LINUX)
WebCore::MemoryPressureHandler::ReliefLogger::setLoggingEnabled(parameters.shouldEnableMemoryPressureReliefLogging);
#endif
platformInitializeWebProcess(WTF::move(parameters));
WTF::setCurrentThreadIsUserInitiated();
MemoryPressureHandler::singleton().install();
if (!parameters.injectedBundlePath.isEmpty())
m_injectedBundle = InjectedBundle::create(parameters, transformHandlesToObjects(parameters.initializationUserData.object()).get());
for (auto& supplement : m_supplements.values())
supplement->initialize(parameters);
#if ENABLE(ICONDATABASE)
m_iconDatabaseProxy->setEnabled(parameters.iconDatabaseEnabled);
#endif
if (!parameters.applicationCacheDirectory.isEmpty())
ApplicationCacheStorage::singleton().setCacheDirectory(parameters.applicationCacheDirectory);
setCacheModel(static_cast<uint32_t>(parameters.cacheModel));
if (!parameters.languages.isEmpty())
overrideUserPreferredLanguages(parameters.languages);
m_textCheckerState = parameters.textCheckerState;
m_fullKeyboardAccessEnabled = parameters.fullKeyboardAccessEnabled;
for (auto& scheme : parameters.urlSchemesRegisteredAsEmptyDocument)
registerURLSchemeAsEmptyDocument(scheme);
for (auto& scheme : parameters.urlSchemesRegisteredAsSecure)
registerURLSchemeAsSecure(scheme);
for (auto& scheme : parameters.urlSchemesRegisteredAsBypassingContentSecurityPolicy)
registerURLSchemeAsBypassingContentSecurityPolicy(scheme);
for (auto& scheme : parameters.urlSchemesForWhichDomainRelaxationIsForbidden)
setDomainRelaxationForbiddenForURLScheme(scheme);
for (auto& scheme : parameters.urlSchemesRegisteredAsLocal)
registerURLSchemeAsLocal(scheme);
for (auto& scheme : parameters.urlSchemesRegisteredAsNoAccess)
registerURLSchemeAsNoAccess(scheme);
for (auto& scheme : parameters.urlSchemesRegisteredAsDisplayIsolated)
registerURLSchemeAsDisplayIsolated(scheme);
for (auto& scheme : parameters.urlSchemesRegisteredAsCORSEnabled)
registerURLSchemeAsCORSEnabled(scheme);
#if ENABLE(CACHE_PARTITIONING)
for (auto& scheme : parameters.urlSchemesRegisteredAsCachePartitioned)
registerURLSchemeAsCachePartitioned(scheme);
#endif
setDefaultRequestTimeoutInterval(parameters.defaultRequestTimeoutInterval);
if (parameters.shouldAlwaysUseComplexTextCodePath)
setAlwaysUsesComplexTextCodePath(true);
if (parameters.shouldUseFontSmoothing)
setShouldUseFontSmoothing(true);
#if PLATFORM(COCOA) || USE(CFNETWORK)
SessionTracker::setIdentifierBase(parameters.uiProcessBundleIdentifier);
#endif
if (parameters.shouldUseTestingNetworkSession)
NetworkStorageSession::switchToNewTestingSession();
#if ENABLE(NETWORK_PROCESS)
ensureNetworkProcessConnection();
#if PLATFORM(COCOA)
if (usesNetworkProcess())
CookieStorageShim::singleton().initialize();
#endif
#endif
setTerminationTimeout(parameters.terminationTimeout);
resetPlugInAutoStartOriginHashes(parameters.plugInAutoStartOriginHashes);
for (auto& origin : parameters.plugInAutoStartOrigins)
m_plugInAutoStartOrigins.add(origin);
setMemoryCacheDisabled(parameters.memoryCacheDisabled);
#if ENABLE(SERVICE_CONTROLS)
setEnabledServices(parameters.hasImageServices, parameters.hasSelectionServices, parameters.hasRichContentServices);
#endif
#if ENABLE(REMOTE_INSPECTOR)
audit_token_t auditToken;
if (parentProcessConnection()->getAuditToken(auditToken)) {
RetainPtr<CFDataRef> auditData = adoptCF(CFDataCreate(nullptr, (const UInt8*)&auditToken, sizeof(auditToken)));
Inspector::RemoteInspector::singleton().setParentProcessInformation(presenterApplicationPid(), auditData);
}
#endif
#if ENABLE(NETSCAPE_PLUGIN_API) && PLATFORM(MAC)
for (auto hostIter = parameters.pluginLoadClientPolicies.begin(); hostIter != parameters.pluginLoadClientPolicies.end(); ++hostIter) {
for (auto bundleIdentifierIter = hostIter->value.begin(); bundleIdentifierIter != hostIter->value.end(); ++bundleIdentifierIter) {
for (auto versionIter = bundleIdentifierIter->value.begin(); versionIter != bundleIdentifierIter->value.end(); ++versionIter)
platformStrategies()->pluginStrategy()->setPluginLoadClientPolicy(static_cast<PluginLoadClientPolicy>(versionIter->value), hostIter->key, bundleIdentifierIter->key, versionIter->key);
}
}
#endif
}
