StorageNamespaceImpl.cpp [plain text]
#include "config.h"
#include "StorageNamespaceImpl.h"
#include "NetworkProcessConnection.h"
#include "StorageAreaImpl.h"
#include "StorageAreaMap.h"
#include "StorageManagerSetMessages.h"
#include "WebPage.h"
#include "WebPageGroupProxy.h"
#include "WebProcess.h"
#include <WebCore/Frame.h>
#include <WebCore/PageGroup.h>
#include <WebCore/SecurityOrigin.h>
#include <WebCore/Settings.h>
#include <WebCore/StorageType.h>
namespace WebKit {
using namespace WebCore;
static HashMap<StorageNamespaceImpl::Identifier, StorageNamespaceImpl*>& sessionStorageNamespaces()
{
static NeverDestroyed<HashMap<StorageNamespaceImpl::Identifier, StorageNamespaceImpl*>> map;
return map;
}
Ref<StorageNamespaceImpl> StorageNamespaceImpl::createSessionStorageNamespace(Identifier identifier, PageIdentifier pageID, unsigned quotaInBytes)
{
if (auto* existingNamespace = sessionStorageNamespaces().get(identifier))
return *existingNamespace;
return adoptRef(*new StorageNamespaceImpl(StorageType::Session, identifier, pageID, nullptr, quotaInBytes));
}
Ref<StorageNamespaceImpl> StorageNamespaceImpl::createLocalStorageNamespace(Identifier identifier, unsigned quotaInBytes)
{
return adoptRef(*new StorageNamespaceImpl(StorageType::Local, identifier, WTF::nullopt, nullptr, quotaInBytes));
}
Ref<StorageNamespaceImpl> StorageNamespaceImpl::createTransientLocalStorageNamespace(Identifier identifier, WebCore::SecurityOrigin& topLevelOrigin, uint64_t quotaInBytes)
{
return adoptRef(*new StorageNamespaceImpl(StorageType::TransientLocal, identifier, WTF::nullopt, &topLevelOrigin, quotaInBytes));
}
StorageNamespaceImpl::StorageNamespaceImpl(WebCore::StorageType storageType, Identifier storageNamespaceID, const Optional<PageIdentifier>& pageIdentifier, WebCore::SecurityOrigin* topLevelOrigin, unsigned quotaInBytes)
: m_storageType(storageType)
, m_storageNamespaceID(storageNamespaceID)
, m_sessionPageID(pageIdentifier)
, m_topLevelOrigin(topLevelOrigin)
, m_quotaInBytes(quotaInBytes)
{
ASSERT(storageType == StorageType::Session || !m_sessionPageID);
if (m_storageType == StorageType::Session) {
ASSERT(!sessionStorageNamespaces().contains(m_storageNamespaceID));
sessionStorageNamespaces().add(m_storageNamespaceID, this);
}
}
StorageNamespaceImpl::~StorageNamespaceImpl()
{
if (m_storageType == StorageType::Session) {
bool wasRemoved = sessionStorageNamespaces().remove(m_storageNamespaceID);
ASSERT_UNUSED(wasRemoved, wasRemoved);
}
}
PAL::SessionID StorageNamespaceImpl::sessionID() const
{
return WebProcess::singleton().sessionID();
}
void StorageNamespaceImpl::destroyStorageAreaMap(StorageAreaMap& map)
{
m_storageAreaMaps.remove(map.securityOrigin().data());
}
Ref<StorageArea> StorageNamespaceImpl::storageArea(const SecurityOriginData& securityOriginData)
{
auto& map = m_storageAreaMaps.ensure(securityOriginData, [&] {
return makeUnique<StorageAreaMap>(*this, securityOriginData.securityOrigin());
}).iterator->value;
return StorageAreaImpl::create(*map);
}
Ref<StorageNamespace> StorageNamespaceImpl::copy(Page& newPage)
{
ASSERT(m_storageNamespaceID);
ASSERT(m_storageType == StorageType::Session);
if (auto networkProcessConnection = WebProcess::singleton().existingNetworkProcessConnection())
networkProcessConnection->connection().send(Messages::StorageManagerSet::CloneSessionStorageNamespace(sessionID(), m_storageNamespaceID, WebPage::fromCorePage(newPage).sessionStorageNamespaceIdentifier()), 0);
return adoptRef(*new StorageNamespaceImpl(m_storageType, WebPage::fromCorePage(newPage).sessionStorageNamespaceIdentifier(), WebPage::fromCorePage(newPage).identifier(), m_topLevelOrigin.get(), m_quotaInBytes));
}
void StorageNamespaceImpl::setSessionIDForTesting(PAL::SessionID)
{
ASSERT_NOT_REACHED();
}
PageIdentifier StorageNamespaceImpl::sessionStoragePageID() const
{
ASSERT(m_storageType == StorageType::Session);
return *m_sessionPageID;
}
uint64_t StorageNamespaceImpl::pageGroupID() const
{
ASSERT(m_storageType == StorageType::Local || m_storageType == StorageType::TransientLocal);
return m_storageNamespaceID.toUInt64();
}
}