2019-09-17 Chris Dumez <cdumez@apple.com>
+ WebProcess class methods should not need to take a sessionID
+ https://bugs.webkit.org/show_bug.cgi?id=201881
+
+ Reviewed by Geoffrey Garen.
+
+ WebProcess class methods should not need to take a sessionID given that we have a single
+ session per WebProcess now.
+
+ * Shared/WebProcessCreationParameters.cpp:
+ (WebKit::WebProcessCreationParameters::encode const):
+ (WebKit::WebProcessCreationParameters::decode):
+ * Shared/WebProcessCreationParameters.h:
+ * Shared/WebProcessDataStoreParameters.h:
+ (WebKit::WebProcessDataStoreParameters::encode const):
+ (WebKit::WebProcessDataStoreParameters::decode):
+ * UIProcess/Plugins/PlugInAutoStartProvider.cpp:
+ (WebKit::PlugInAutoStartProvider::addAutoStartOriginHash):
+ (WebKit::PlugInAutoStartProvider::autoStartOriginHashesCopy const):
+ (WebKit::PlugInAutoStartProvider::setAutoStartOriginsTableWithItemsPassingTest):
+ (WebKit::PlugInAutoStartProvider::didReceiveUserInteraction):
+ * UIProcess/Plugins/PlugInAutoStartProvider.h:
+ * UIProcess/WebProcessPool.cpp:
+ (WebKit::WebProcessPool::webProcessDataStoreParameters):
+ (WebKit::WebProcessPool::initializeNewWebProcess):
+ * UIProcess/WebProcessPool.h:
+ (WebKit::WebProcessPool::sendToAllProcesses):
+ (WebKit::WebProcessPool::sendToAllProcessesForSession):
+ * UIProcess/WebProcessProxy.cpp:
+ (WebKit::WebProcessProxy::fetchWebsiteData):
+ (WebKit::WebProcessProxy::deleteWebsiteData):
+ (WebKit::WebProcessProxy::deleteWebsiteDataForOrigins):
+ (WebKit::WebProcessProxy::establishServiceWorkerContext):
+ * WebProcess/Plugins/PluginView.cpp:
+ (WebKit::PluginView::pluginDidReceiveUserInteraction):
+ * WebProcess/WebCoreSupport/WebPlugInClient.cpp:
+ (WebKit::WebPlugInClient::didStartFromOrigin):
+ * WebProcess/WebPage/WebPage.cpp:
+ (WebKit::WebPage::close):
+ * WebProcess/WebProcess.cpp:
+ (WebKit::WebProcess::initializeWebProcess):
+ (WebKit::WebProcess::setWebsiteDataStoreParameters):
+ (WebKit::WebProcess::removeWebPage):
+ (WebKit::WebProcess::isPlugInAutoStartOriginHash):
+ (WebKit::WebProcess::shouldPlugInAutoStartFromOrigin):
+ (WebKit::WebProcess::plugInDidStartFromOrigin):
+ (WebKit::WebProcess::didAddPlugInAutoStartOriginHash):
+ (WebKit::WebProcess::resetPlugInAutoStartOriginHashes):
+ (WebKit::WebProcess::plugInDidReceiveUserInteraction):
+ (WebKit::WebProcess::fetchWebsiteData):
+ (WebKit::WebProcess::deleteWebsiteData):
+ (WebKit::WebProcess::deleteWebsiteDataForOrigins):
+ (WebKit::WebProcess::establishWorkerContextConnectionToNetworkProcess):
+ * WebProcess/WebProcess.h:
+ * WebProcess/WebProcess.messages.in:
+
+2019-09-17 Chris Dumez <cdumez@apple.com>
+
WebMDNSRegister no longer needs to be provided sessionIDs
https://bugs.webkit.org/show_bug.cgi?id=201876
encoder << notificationPermissions;
#endif
- encoder << plugInAutoStartOriginHashes;
encoder << plugInAutoStartOrigins;
encoder << memoryCacheDisabled;
encoder << attrStyleEnabled;
return false;
#endif
- if (!decoder.decode(parameters.plugInAutoStartOriginHashes))
- return false;
if (!decoder.decode(parameters.plugInAutoStartOrigins))
return false;
if (!decoder.decode(parameters.memoryCacheDisabled))
HashMap<String, bool> notificationPermissions;
#endif
- HashMap<PAL::SessionID, HashMap<unsigned, WallTime>> plugInAutoStartOriginHashes;
Vector<String> plugInAutoStartOrigins;
#if ENABLE(NETSCAPE_PLUGIN_API)
SandboxExtension::Handle mediaKeyStorageDirectoryExtensionHandle;
String javaScriptConfigurationDirectory;
SandboxExtension::Handle javaScriptConfigurationDirectoryExtensionHandle;
+ HashMap<unsigned, WallTime> plugInAutoStartOriginHashes;
bool resourceLoadStatisticsEnabled { false };
template<class Encoder> void encode(Encoder&) const;
encoder << mediaKeyStorageDirectoryExtensionHandle;
encoder << javaScriptConfigurationDirectory;
encoder << javaScriptConfigurationDirectoryExtensionHandle;
+ encoder << plugInAutoStartOriginHashes;
encoder << resourceLoadStatisticsEnabled;
}
decoder >> javaScriptConfigurationDirectoryExtensionHandle;
if (!javaScriptConfigurationDirectoryExtensionHandle)
return WTF::nullopt;
+
+ Optional<HashMap<unsigned, WallTime>> plugInAutoStartOriginHashes;
+ decoder >> plugInAutoStartOriginHashes;
+ if (!plugInAutoStartOriginHashes)
+ return WTF::nullopt;
bool resourceLoadStatisticsEnabled = false;
if (!decoder.decode(resourceLoadStatisticsEnabled))
WTFMove(*mediaKeyStorageDirectoryExtensionHandle),
WTFMove(javaScriptConfigurationDirectory),
WTFMove(*javaScriptConfigurationDirectoryExtensionHandle),
+ WTFMove(*plugInAutoStartOriginHashes),
resourceLoadStatisticsEnabled
};
}
it->value.set(plugInOriginHash, expirationTime);
sessionIterator->value.set(plugInOriginHash, pageOrigin);
- m_processPool->sendToAllProcesses(Messages::WebProcess::DidAddPlugInAutoStartOriginHash(plugInOriginHash, expirationTime, sessionID));
+ m_processPool->sendToAllProcessesForSession(Messages::WebProcess::DidAddPlugInAutoStartOriginHash(plugInOriginHash, expirationTime), sessionID);
if (!sessionID.isEphemeral())
m_processPool->client().plugInAutoStartOriginHashesChanged(m_processPool);
}
-SessionPlugInAutoStartOriginMap PlugInAutoStartProvider::autoStartOriginHashesCopy() const
+PlugInAutoStartOriginMap PlugInAutoStartProvider::autoStartOriginHashesCopy(PAL::SessionID sessionID) const
{
- SessionPlugInAutoStartOriginMap sessionMap;
+ PlugInAutoStartOriginMap map;
- for (const auto& sessionKeyOriginHash : m_autoStartTable) {
- PlugInAutoStartOriginMap& map = sessionMap.add(sessionKeyOriginHash.key, PlugInAutoStartOriginMap()).iterator->value;
- for (const auto& keyOriginHash : sessionKeyOriginHash.value) {
+ auto it = m_autoStartTable.find(sessionID);
+ if (it != m_autoStartTable.end()) {
+ for (const auto& keyOriginHash : it->value) {
for (const auto& originHash : keyOriginHash.value)
map.set(originHash.key, originHash.value);
}
}
- return sessionMap;
+ return map;
}
Ref<API::Dictionary> PlugInAutoStartProvider::autoStartOriginsTableCopy() const
ast.set(strDict.key, hashes);
}
- m_processPool->sendToAllProcesses(Messages::WebProcess::ResetPlugInAutoStartOriginDefaultHashes(hashMap));
+ m_processPool->sendToAllProcessesForSession(Messages::WebProcess::ResetPlugInAutoStartOriginHashes(hashMap), PAL::SessionID::defaultSessionID());
}
void PlugInAutoStartProvider::setAutoStartOriginsArray(API::Array& originList)
WallTime newExpirationTime = expirationTimeFromNow();
m_autoStartTable.add(sessionID, AutoStartTable()).iterator->value.add(it->value, PlugInAutoStartOriginMap()).iterator->value.set(plugInOriginHash, newExpirationTime);
- m_processPool->sendToAllProcesses(Messages::WebProcess::DidAddPlugInAutoStartOriginHash(plugInOriginHash, newExpirationTime, sessionID));
+ m_processPool->sendToAllProcessesForSession(Messages::WebProcess::DidAddPlugInAutoStartOriginHash(plugInOriginHash, newExpirationTime), sessionID);
m_processPool->client().plugInAutoStartOriginHashesChanged(m_processPool);
}
void setAutoStartOriginsFilteringOutEntriesAddedAfterTime(API::Dictionary&, WallTime);
void setAutoStartOriginsArray(API::Array&);
- SessionPlugInAutoStartOriginMap autoStartOriginHashesCopy() const;
+ PlugInAutoStartOriginMap autoStartOriginHashesCopy(PAL::SessionID) const;
const PlugInAutoStartOrigins& autoStartOrigins() const { return m_autoStartOrigins; }
private:
SandboxExtension::Handle javaScriptConfigurationDirectoryExtensionHandle;
if (!javaScriptConfigurationDirectory.isEmpty())
SandboxExtension::createHandleWithoutResolvingPath(javaScriptConfigurationDirectory, SandboxExtension::Type::ReadWrite, javaScriptConfigurationDirectoryExtensionHandle);
+
+ auto plugInAutoStartOriginHashes = m_plugInAutoStartProvider.autoStartOriginHashesCopy(websiteDataStore.sessionID());
return WebProcessDataStoreParameters {
websiteDataStore.sessionID(),
WTFMove(mediaKeyStorageDirectoryExtensionHandle),
WTFMove(javaScriptConfigurationDirectory),
WTFMove(javaScriptConfigurationDirectoryExtensionHandle),
+ WTFMove(plugInAutoStartOriginHashes),
websiteDataStore.resourceLoadStatisticsEnabled()
};
}
parameters.notificationPermissions = supplement<WebNotificationManagerProxy>()->notificationPermissions();
#endif
- parameters.plugInAutoStartOriginHashes = m_plugInAutoStartProvider.autoStartOriginHashesCopy();
parameters.plugInAutoStartOrigins = copyToVector(m_plugInAutoStartProvider.autoStartOrigins());
parameters.memoryCacheDisabled = m_memoryCacheDisabled;
IPC::Connection* networkingProcessConnection();
template<typename T> void sendToAllProcesses(const T& message);
+ template<typename T> void sendToAllProcessesForSession(const T& message, PAL::SessionID);
template<typename T> void sendToAllProcessesRelaunchingThemIfNecessary(const T& message);
template<typename T> void sendToOneProcess(T&& message);
}
template<typename T>
+void WebProcessPool::sendToAllProcessesForSession(const T& message, PAL::SessionID sessionID)
+{
+ size_t processCount = m_processes.size();
+ for (size_t i = 0; i < processCount; ++i) {
+ WebProcessProxy* process = m_processes[i].get();
+ if (process->canSendMessage() && !process->isPrewarmed() && process->sessionID() == sessionID)
+ process->send(T(message), 0);
+ }
+}
+
+template<typename T>
void WebProcessPool::sendToAllProcessesRelaunchingThemIfNecessary(const T& message)
{
// FIXME (Multi-WebProcess): WebProcessPool doesn't track processes that have exited, so it cannot relaunch these. Perhaps this functionality won't be needed in this mode.
void WebProcessProxy::fetchWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> dataTypes, CompletionHandler<void(WebsiteData)>&& completionHandler)
{
ASSERT(canSendMessage());
+ ASSERT_UNUSED(sessionID, sessionID == this->sessionID());
auto token = throttler().backgroundActivityToken();
- RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is fetching Website data", this);
+ RELEASE_LOG_IF(isReleaseLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is fetching Website data", this);
- connection()->sendWithAsyncReply(Messages::WebProcess::FetchWebsiteData(sessionID, dataTypes), [this, protectedThis = makeRef(*this), token, completionHandler = WTFMove(completionHandler), sessionID] (auto reply) mutable {
+ connection()->sendWithAsyncReply(Messages::WebProcess::FetchWebsiteData(dataTypes), [this, protectedThis = makeRef(*this), token, completionHandler = WTFMove(completionHandler)] (auto reply) mutable {
#if RELEASE_LOG_DISABLED
- UNUSED_PARAM(sessionID);
UNUSED_PARAM(this);
#endif
completionHandler(WTFMove(reply));
- RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is releasing a background assertion because the Web process is done fetching Website data", this);
+ RELEASE_LOG_IF(isReleaseLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is releasing a background assertion because the Web process is done fetching Website data", this);
});
}
void WebProcessProxy::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> dataTypes, WallTime modifiedSince, CompletionHandler<void()>&& completionHandler)
{
ASSERT(canSendMessage());
+ ASSERT_UNUSED(sessionID, sessionID == this->sessionID());
auto token = throttler().backgroundActivityToken();
- RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is deleting Website data", this);
+ RELEASE_LOG_IF(isReleaseLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is deleting Website data", this);
- connection()->sendWithAsyncReply(Messages::WebProcess::DeleteWebsiteData(sessionID, dataTypes, modifiedSince), [this, protectedThis = makeRef(*this), token, completionHandler = WTFMove(completionHandler), sessionID] () mutable {
+ connection()->sendWithAsyncReply(Messages::WebProcess::DeleteWebsiteData(dataTypes, modifiedSince), [this, protectedThis = makeRef(*this), token, completionHandler = WTFMove(completionHandler)] () mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(this);
- UNUSED_PARAM(sessionID);
#endif
completionHandler();
- RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is releasing a background assertion because the Web process is done deleting Website data", this);
+ RELEASE_LOG_IF(isReleaseLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is releasing a background assertion because the Web process is done deleting Website data", this);
});
}
void WebProcessProxy::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, OptionSet<WebsiteDataType> dataTypes, const Vector<WebCore::SecurityOriginData>& origins, CompletionHandler<void()>&& completionHandler)
{
ASSERT(canSendMessage());
+ ASSERT_UNUSED(sessionID, sessionID == this->sessionID());
auto token = throttler().backgroundActivityToken();
- RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is deleting Website data for several origins", this);
+ RELEASE_LOG_IF(isReleaseLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is deleting Website data for several origins", this);
- connection()->sendWithAsyncReply(Messages::WebProcess::DeleteWebsiteDataForOrigins(sessionID, dataTypes, origins), [this, protectedThis = makeRef(*this), token, completionHandler = WTFMove(completionHandler), sessionID] () mutable {
+ connection()->sendWithAsyncReply(Messages::WebProcess::DeleteWebsiteDataForOrigins(dataTypes, origins), [this, protectedThis = makeRef(*this), token, completionHandler = WTFMove(completionHandler)] () mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(this);
- UNUSED_PARAM(sessionID);
#endif
completionHandler();
- RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is releasing a background assertion because the Web process is done deleting Website data for several origins", this);
+ RELEASE_LOG_IF(isReleaseLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is releasing a background assertion because the Web process is done deleting Website data for several origins", this);
});
}
#if ENABLE(SERVICE_WORKER)
void WebProcessProxy::establishServiceWorkerContext(const WebPreferencesStore& store)
{
- send(Messages::WebProcess::EstablishWorkerContextConnectionToNetworkProcess { processPool().defaultPageGroup().pageGroupID(), m_serviceWorkerInformation->serviceWorkerPageProxyID, m_serviceWorkerInformation->serviceWorkerPageID, store, *m_registrableDomain, m_websiteDataStore->sessionID() }, 0);
+ send(Messages::WebProcess::EstablishWorkerContextConnectionToNetworkProcess { processPool().defaultPageGroup().pageGroupID(), m_serviceWorkerInformation->serviceWorkerPageProxyID, m_serviceWorkerInformation->serviceWorkerPageID, store, *m_registrableDomain }, 0);
}
void WebProcessProxy::setServiceWorkerUserAgent(const String& userAgent)
String pluginOrigin = plugInImageElement.loadedUrl().host().toString();
String mimeType = plugInImageElement.serviceType();
- WebProcess::singleton().plugInDidReceiveUserInteraction(pageOrigin, pluginOrigin, mimeType, plugInImageElement.document().page()->sessionID());
+ WebProcess::singleton().plugInDidReceiveUserInteraction(pageOrigin, pluginOrigin, mimeType);
}
bool PluginView::shouldCreateTransientPaintingSnapshot() const
void WebPlugInClient::didStartFromOrigin(const String& pageOrigin, const String& pluginOrigin, const String& mimeType, PAL::SessionID sessionID)
{
- WebProcess::singleton().plugInDidStartFromOrigin(pageOrigin, pluginOrigin, mimeType, sessionID);
+ ASSERT_UNUSED(sessionID, sessionID == WebProcess::singleton().sessionID());
+ WebProcess::singleton().plugInDidStartFromOrigin(pageOrigin, pluginOrigin, mimeType);
}
} // namespace WebKit
m_mainFrame->coreFrame()->loader().detachFromParent();
m_drawingArea = nullptr;
- auto sessionID = this->sessionID();
DeferredPageDestructor::createDeferredPageDestructor(WTFMove(m_page), this);
bool isRunningModal = m_isRunningModal;
#endif
// The WebPage can be destroyed by this call.
- WebProcess::singleton().removeWebPage(sessionID, m_identifier);
+ WebProcess::singleton().removeWebPage(m_identifier);
WebProcess::singleton().updateActivePages();
#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)
addSupplement<UserMediaCaptureManager>();
#endif
-
- m_plugInAutoStartOriginHashes.add(PAL::SessionID::defaultSessionID(), HashMap<unsigned, WallTime>());
Gigacage::forbidDisablingPrimitiveGigacage();
}
setTerminationTimeout(parameters.terminationTimeout);
- resetPlugInAutoStartOriginHashes(parameters.plugInAutoStartOriginHashes);
for (auto& origin : parameters.plugInAutoStartOrigins)
m_plugInAutoStartOrigins.add(origin);
ResourceLoadObserver::setShared(*new WebResourceLoadObserver);
#endif
+ resetPlugInAutoStartOriginHashes(WTFMove(parameters.plugInAutoStartOriginHashes));
+
for (auto& supplement : m_supplements.values())
supplement->setWebsiteDataStore(parameters);
ASSERT(result.iterator->value);
}
-void WebProcess::removeWebPage(PAL::SessionID sessionID, PageIdentifier pageID)
+void WebProcess::removeWebPage(PageIdentifier pageID)
{
- ASSERT(sessionID == this->sessionID());
ASSERT(m_pageMap.contains(pageID));
pageWillLeaveWindow(pageID);
return hasher.hash();
}
-bool WebProcess::isPlugInAutoStartOriginHash(unsigned plugInOriginHash, PAL::SessionID sessionID)
+bool WebProcess::isPlugInAutoStartOriginHash(unsigned plugInOriginHash)
{
- HashMap<PAL::SessionID, HashMap<unsigned, WallTime>>::const_iterator sessionIterator = m_plugInAutoStartOriginHashes.find(sessionID);
- HashMap<unsigned, WallTime>::const_iterator it;
- bool contains = false;
+ auto it = m_plugInAutoStartOriginHashes.find(plugInOriginHash);
+ if (it == m_plugInAutoStartOriginHashes.end())
+ return false;
- if (sessionIterator != m_plugInAutoStartOriginHashes.end()) {
- it = sessionIterator->value.find(plugInOriginHash);
- contains = it != sessionIterator->value.end();
- }
- if (!contains) {
- sessionIterator = m_plugInAutoStartOriginHashes.find(PAL::SessionID::defaultSessionID());
- it = sessionIterator->value.find(plugInOriginHash);
- if (it == sessionIterator->value.end())
- return false;
- }
return WallTime::now() < it->value;
}
#endif
// Lastly check against the more explicit hash list.
- return isPlugInAutoStartOriginHash(hashForPlugInOrigin(pageOrigin, pluginOrigin, mimeType), webPage.sessionID());
+ return isPlugInAutoStartOriginHash(hashForPlugInOrigin(pageOrigin, pluginOrigin, mimeType));
}
-void WebProcess::plugInDidStartFromOrigin(const String& pageOrigin, const String& pluginOrigin, const String& mimeType, PAL::SessionID sessionID)
+void WebProcess::plugInDidStartFromOrigin(const String& pageOrigin, const String& pluginOrigin, const String& mimeType)
{
if (pageOrigin.isEmpty()) {
LOG(Plugins, "Not adding empty page origin");
}
unsigned plugInOriginHash = hashForPlugInOrigin(pageOrigin, pluginOrigin, mimeType);
- if (isPlugInAutoStartOriginHash(plugInOriginHash, sessionID)) {
+ if (isPlugInAutoStartOriginHash(plugInOriginHash)) {
LOG(Plugins, "Hash %x already exists as auto-start origin (request for %s)", plugInOriginHash, pageOrigin.utf8().data());
return;
}
// comes back from the parent process. Temporarily add this hash to the list with a thirty
// second timeout. That way, even if the parent decides not to add it, we'll only be
// incorrect for a little while.
- m_plugInAutoStartOriginHashes.add(sessionID, HashMap<unsigned, WallTime>()).iterator->value.set(plugInOriginHash, WallTime::now() + 30_s * 1000);
+ m_plugInAutoStartOriginHashes.set(plugInOriginHash, WallTime::now() + 30_s * 1000);
- parentProcessConnection()->send(Messages::WebProcessPool::AddPlugInAutoStartOriginHash(pageOrigin, plugInOriginHash, sessionID), 0);
+ parentProcessConnection()->send(Messages::WebProcessPool::AddPlugInAutoStartOriginHash(pageOrigin, plugInOriginHash, sessionID()), 0);
}
-void WebProcess::didAddPlugInAutoStartOriginHash(unsigned plugInOriginHash, WallTime expirationTime, PAL::SessionID sessionID)
+void WebProcess::didAddPlugInAutoStartOriginHash(unsigned plugInOriginHash, WallTime expirationTime)
{
// When called, some web process (which also might be this one) added the origin for auto-starting,
// or received user interaction.
// Set the bit to avoid having redundantly call into the UI process upon user interaction.
- m_plugInAutoStartOriginHashes.add(sessionID, HashMap<unsigned, WallTime>()).iterator->value.set(plugInOriginHash, expirationTime);
+ m_plugInAutoStartOriginHashes.set(plugInOriginHash, expirationTime);
}
-void WebProcess::resetPlugInAutoStartOriginDefaultHashes(const HashMap<unsigned, WallTime>& hashes)
+void WebProcess::resetPlugInAutoStartOriginHashes(HashMap<unsigned, WallTime>&& hashes)
{
- m_plugInAutoStartOriginHashes.clear();
- m_plugInAutoStartOriginHashes.add(PAL::SessionID::defaultSessionID(), HashMap<unsigned, WallTime>()).iterator->value.swap(const_cast<HashMap<unsigned, WallTime>&>(hashes));
+ m_plugInAutoStartOriginHashes = WTFMove(hashes);
}
-void WebProcess::resetPlugInAutoStartOriginHashes(const HashMap<PAL::SessionID, HashMap<unsigned, WallTime>>& hashes)
-{
- m_plugInAutoStartOriginHashes.swap(const_cast<HashMap<PAL::SessionID, HashMap<unsigned, WallTime>>&>(hashes));
-}
-
-void WebProcess::plugInDidReceiveUserInteraction(const String& pageOrigin, const String& pluginOrigin, const String& mimeType, PAL::SessionID sessionID)
+void WebProcess::plugInDidReceiveUserInteraction(const String& pageOrigin, const String& pluginOrigin, const String& mimeType)
{
if (pageOrigin.isEmpty())
return;
if (!plugInOriginHash)
return;
- HashMap<PAL::SessionID, HashMap<unsigned, WallTime>>::const_iterator sessionIterator = m_plugInAutoStartOriginHashes.find(sessionID);
- HashMap<unsigned, WallTime>::const_iterator it;
- bool contains = false;
- if (sessionIterator != m_plugInAutoStartOriginHashes.end()) {
- it = sessionIterator->value.find(plugInOriginHash);
- contains = it != sessionIterator->value.end();
- }
- if (!contains) {
- sessionIterator = m_plugInAutoStartOriginHashes.find(PAL::SessionID::defaultSessionID());
- it = sessionIterator->value.find(plugInOriginHash);
- if (it == sessionIterator->value.end())
- return;
- }
+ auto it = m_plugInAutoStartOriginHashes.find(plugInOriginHash);
+ if (it == m_plugInAutoStartOriginHashes.end())
+ return;
if (it->value - WallTime::now() > plugInAutoStartExpirationTimeUpdateThreshold)
return;
- parentProcessConnection()->send(Messages::WebProcessPool::PlugInDidReceiveUserInteraction(plugInOriginHash, sessionID), 0);
+ parentProcessConnection()->send(Messages::WebProcessPool::PlugInDidReceiveUserInteraction(plugInOriginHash, sessionID()), 0);
}
void WebProcess::setPluginLoadClientPolicy(uint8_t policy, const String& host, const String& bundleIdentifier, const String& versionString)
PageCache::singleton().pruneToSizeNow(0, PruningReason::MemoryPressure);
}
-void WebProcess::fetchWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, CompletionHandler<void(WebsiteData&&)>&& completionHandler)
+void WebProcess::fetchWebsiteData(OptionSet<WebsiteDataType> websiteDataTypes, CompletionHandler<void(WebsiteData&&)>&& completionHandler)
{
WebsiteData websiteData;
if (websiteDataTypes.contains(WebsiteDataType::MemoryCache)) {
- for (auto& origin : MemoryCache::singleton().originsWithCache(sessionID))
+ for (auto& origin : MemoryCache::singleton().originsWithCache(sessionID()))
websiteData.entries.append(WebsiteData::Entry { origin->data(), WebsiteDataType::MemoryCache, 0 });
}
completionHandler(WTFMove(websiteData));
}
-void WebProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, WallTime modifiedSince, CompletionHandler<void()>&& completionHandler)
+void WebProcess::deleteWebsiteData(OptionSet<WebsiteDataType> websiteDataTypes, WallTime modifiedSince, CompletionHandler<void()>&& completionHandler)
{
UNUSED_PARAM(modifiedSince);
if (websiteDataTypes.contains(WebsiteDataType::MemoryCache)) {
PageCache::singleton().pruneToSizeNow(0, PruningReason::None);
- MemoryCache::singleton().evictResources(sessionID);
+ MemoryCache::singleton().evictResources(sessionID());
CrossOriginPreflightResultCache::singleton().clear();
}
completionHandler();
}
-void WebProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<WebCore::SecurityOriginData>& originDatas, CompletionHandler<void()>&& completionHandler)
+void WebProcess::deleteWebsiteDataForOrigins(OptionSet<WebsiteDataType> websiteDataTypes, const Vector<WebCore::SecurityOriginData>& originDatas, CompletionHandler<void()>&& completionHandler)
{
if (websiteDataTypes.contains(WebsiteDataType::MemoryCache)) {
HashSet<RefPtr<SecurityOrigin>> origins;
for (auto& originData : originDatas)
origins.add(originData.securityOrigin());
- MemoryCache::singleton().removeResourcesWithOrigins(sessionID, origins);
+ MemoryCache::singleton().removeResourcesWithOrigins(sessionID(), origins);
}
completionHandler();
}
}
#if ENABLE(SERVICE_WORKER)
-void WebProcess::establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store, RegistrableDomain&& registrableDomain, PAL::SessionID sessionID)
+void WebProcess::establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store, RegistrableDomain&& registrableDomain)
{
// We are in the Service Worker context process and the call below establishes our connection to the Network Process
// by calling ensureNetworkProcessConnection. SWContextManager needs to use the same underlying IPC::Connection as the
// NetworkProcessConnection for synchronization purposes.
auto& ipcConnection = ensureNetworkProcessConnection().connection();
- SWContextManager::singleton().setConnection(makeUnique<WebSWContextManagerConnection>(ipcConnection, WTFMove(registrableDomain), sessionID, pageGroupID, webPageProxyID, pageID, store));
+ SWContextManager::singleton().setConnection(makeUnique<WebSWContextManagerConnection>(ipcConnection, WTFMove(registrableDomain), sessionID(), pageGroupID, webPageProxyID, pageID, store));
}
void WebProcess::registerServiceWorkerClients()
WebPage* webPage(WebCore::PageIdentifier) const;
void createWebPage(WebCore::PageIdentifier, WebPageCreationParameters&&);
- void removeWebPage(PAL::SessionID, WebCore::PageIdentifier);
+ void removeWebPage(WebCore::PageIdentifier);
WebPage* focusedWebPage() const;
InjectedBundle* injectedBundle() const { return m_injectedBundle.get(); }
#endif
bool shouldPlugInAutoStartFromOrigin(WebPage&, const String& pageOrigin, const String& pluginOrigin, const String& mimeType);
- void plugInDidStartFromOrigin(const String& pageOrigin, const String& pluginOrigin, const String& mimeType, PAL::SessionID);
- void plugInDidReceiveUserInteraction(const String& pageOrigin, const String& pluginOrigin, const String& mimeType, PAL::SessionID);
+ void plugInDidStartFromOrigin(const String& pageOrigin, const String& pluginOrigin, const String& mimeType);
+ void plugInDidReceiveUserInteraction(const String& pageOrigin, const String& pluginOrigin, const String& mimeType);
void setPluginLoadClientPolicy(uint8_t policy, const String& host, const String& bundleIdentifier, const String& versionString);
void resetPluginLoadClientPolicies(const HashMap<String, HashMap<String, HashMap<String, uint8_t>>>&);
void clearPluginClientPolicies();
void userPreferredLanguagesChanged(const Vector<String>&) const;
void fullKeyboardAccessModeChanged(bool fullKeyboardAccessEnabled);
- bool isPlugInAutoStartOriginHash(unsigned plugInOriginHash, PAL::SessionID);
- void didAddPlugInAutoStartOriginHash(unsigned plugInOriginHash, WallTime expirationTime, PAL::SessionID);
- void resetPlugInAutoStartOriginDefaultHashes(const HashMap<unsigned, WallTime>& hashes);
- void resetPlugInAutoStartOriginHashes(const HashMap<PAL::SessionID, HashMap<unsigned, WallTime>>& hashes);
+ bool isPlugInAutoStartOriginHash(unsigned plugInOriginHash);
+ void didAddPlugInAutoStartOriginHash(unsigned plugInOriginHash, WallTime expirationTime);
+ void resetPlugInAutoStartOriginHashes(HashMap<unsigned, WallTime>&& hashes);
void platformSetCacheModel(CacheModel);
#endif
#if ENABLE(SERVICE_WORKER)
- void establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&, WebCore::RegistrableDomain&&, PAL::SessionID);
+ void establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&, WebCore::RegistrableDomain&&);
void registerServiceWorkerClients();
#endif
void releasePageCache();
- void fetchWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, CompletionHandler<void(WebsiteData&&)>&&);
- void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, WallTime modifiedSince, CompletionHandler<void()>&&);
- void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>& origins, CompletionHandler<void()>&&);
+ void fetchWebsiteData(OptionSet<WebsiteDataType>, CompletionHandler<void(WebsiteData&&)>&&);
+ void deleteWebsiteData(OptionSet<WebsiteDataType>, WallTime modifiedSince, CompletionHandler<void()>&&);
+ void deleteWebsiteDataForOrigins(OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>& origins, CompletionHandler<void()>&&);
void setMemoryCacheDisabled(bool);
#endif
RefPtr<WebInspectorInterruptDispatcher> m_webInspectorInterruptDispatcher;
- HashMap<PAL::SessionID, HashMap<unsigned, WallTime>> m_plugInAutoStartOriginHashes;
+ HashMap<unsigned, WallTime> m_plugInAutoStartOriginHashes;
HashSet<String> m_plugInAutoStartOrigins;
bool m_hasSetCacheModel { false };
FullKeyboardAccessModeChanged(bool fullKeyboardAccessEnabled)
# Plug-ins.
- DidAddPlugInAutoStartOriginHash(uint32_t hash, WallTime expirationTime, PAL::SessionID sessionID)
- ResetPlugInAutoStartOriginDefaultHashes(HashMap<uint32_t,WallTime> hashes)
- ResetPlugInAutoStartOriginHashes(HashMap<PAL::SessionID, HashMap<uint32_t,WallTime>> hashes)
+ DidAddPlugInAutoStartOriginHash(uint32_t hash, WallTime expirationTime)
+ ResetPlugInAutoStartOriginHashes(HashMap<uint32_t,WallTime> hashes)
SetPluginLoadClientPolicy(uint8_t policy, String host, String bundleIdentifier, String versionString)
ResetPluginLoadClientPolicies(HashMap<String, HashMap<String, HashMap<String, uint8_t>>> pluginLoadClientPolicies)
ClearPluginClientPolicies()
ReleasePageCache()
- FetchWebsiteData(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes) -> (struct WebKit::WebsiteData websiteData) Async
- DeleteWebsiteData(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes, WallTime modifiedSince) -> () Async
- DeleteWebsiteDataForOrigins(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes, Vector<WebCore::SecurityOriginData> origins) -> () Async
+ FetchWebsiteData(OptionSet<WebKit::WebsiteDataType> websiteDataTypes) -> (struct WebKit::WebsiteData websiteData) Async
+ DeleteWebsiteData(OptionSet<WebKit::WebsiteDataType> websiteDataTypes, WallTime modifiedSince) -> () Async
+ DeleteWebsiteDataForOrigins(OptionSet<WebKit::WebsiteDataType> websiteDataTypes, Vector<WebCore::SecurityOriginData> origins) -> () Async
SetHiddenPageDOMTimerThrottlingIncreaseLimit(int milliseconds)
#if PLATFORM(COCOA)
#endif
#if ENABLE(SERVICE_WORKER)
- EstablishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebKit::WebPageProxyIdentifier webPageProxyID, WebCore::PageIdentifier pageID, struct WebKit::WebPreferencesStore store, WebCore::RegistrableDomain domain, PAL::SessionID initialSessionID)
+ EstablishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebKit::WebPageProxyIdentifier webPageProxyID, WebCore::PageIdentifier pageID, struct WebKit::WebPreferencesStore store, WebCore::RegistrableDomain domain)
RegisterServiceWorkerClients()
#endif
git://git.webkit.org / WebKit-https.git / commitdiff