StorageAreaMap.cpp [plain text]
#include "config.h"
#include "StorageAreaMap.h"
#include "Logging.h"
#include "NetworkProcessConnection.h"
#include "StorageAreaImpl.h"
#include "StorageAreaMapMessages.h"
#include "StorageManagerSetMessages.h"
#include "StorageNamespaceImpl.h"
#include "WebPage.h"
#include "WebPageGroupProxy.h"
#include "WebProcess.h"
#include <WebCore/DOMWindow.h>
#include <WebCore/Document.h>
#include <WebCore/Frame.h>
#include <WebCore/Page.h>
#include <WebCore/PageGroup.h>
#include <WebCore/SecurityOriginData.h>
#include <WebCore/Storage.h>
#include <WebCore/StorageEventDispatcher.h>
#include <WebCore/StorageMap.h>
#include <WebCore/StorageType.h>
namespace WebKit {
using namespace WebCore;
StorageAreaMap::StorageAreaMap(StorageNamespaceImpl& storageNamespace, Ref<WebCore::SecurityOrigin>&& securityOrigin)
: m_namespace(storageNamespace)
, m_securityOrigin(WTFMove(securityOrigin))
, m_quotaInBytes(storageNamespace.quotaInBytes())
, m_type(storageNamespace.storageType())
{
connect();
}
StorageAreaMap::~StorageAreaMap()
{
disconnect();
}
unsigned StorageAreaMap::length()
{
return ensureMap().length();
}
String StorageAreaMap::key(unsigned index)
{
return ensureMap().key(index);
}
String StorageAreaMap::item(const String& key)
{
return ensureMap().getItem(key);
}
void StorageAreaMap::setItem(Frame* sourceFrame, StorageAreaImpl* sourceArea, const String& key, const String& value, bool& quotaException)
{
auto& map = ensureMap();
ASSERT(map.hasOneRef());
String oldValue;
quotaException = false;
map.setItem(key, value, oldValue, quotaException);
if (quotaException)
return;
if (oldValue == value)
return;
m_pendingValueChanges.add(key);
if (m_mapID)
WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManagerSet::SetItem(*m_mapID, sourceArea->identifier(), m_currentSeed, key, value, sourceFrame->document()->url().string()), 0);
else
RELEASE_LOG_ERROR(Storage, "StorageAreaMap::setItem failed because storage map ID is invalid");
}
void StorageAreaMap::removeItem(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceArea, const String& key)
{
auto& map = ensureMap();
ASSERT(map.hasOneRef());
String oldValue;
map.removeItem(key, oldValue);
if (oldValue.isNull())
return;
m_pendingValueChanges.add(key);
if (m_mapID)
WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManagerSet::RemoveItem(*m_mapID, sourceArea->identifier(), m_currentSeed, key, sourceFrame->document()->url().string()), 0);
else
RELEASE_LOG_ERROR(Storage, "StorageAreaMap::removeItem failed because storage map ID is invalid");
}
void StorageAreaMap::clear(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceArea)
{
connect();
resetValues();
m_hasPendingClear = true;
m_map = StorageMap::create(m_quotaInBytes);
if (m_mapID)
WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManagerSet::Clear(*m_mapID, sourceArea->identifier(), m_currentSeed, sourceFrame->document()->url().string()), 0);
else
RELEASE_LOG_ERROR(Storage, "StorageAreaMap::clear failed because storage map ID is invalid");
}
bool StorageAreaMap::contains(const String& key)
{
return ensureMap().contains(key);
}
void StorageAreaMap::resetValues()
{
m_map = nullptr;
m_pendingValueChanges.clear();
m_hasPendingClear = false;
++m_currentSeed;
}
StorageMap& StorageAreaMap::ensureMap()
{
connect();
if (!m_map) {
m_map = StorageMap::create(m_quotaInBytes);
if (m_mapID) {
IPC::UnboundedSynchronousIPCScope unboundedSynchronousIPCScope;
HashMap<String, String> values;
WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::StorageManagerSet::GetValues(*m_mapID), Messages::StorageManagerSet::GetValues::Reply(values), 0);
m_map->importItems(WTFMove(values));
} else
RELEASE_LOG_ERROR(Storage, "StorageAreaMap::ensureMap failed to load from network process because storage map ID is invalid");
}
return *m_map;
}
void StorageAreaMap::didSetItem(uint64_t mapSeed, const String& key, bool quotaError)
{
if (m_currentSeed != mapSeed)
return;
ASSERT(m_pendingValueChanges.contains(key));
if (quotaError) {
resetValues();
return;
}
m_pendingValueChanges.remove(key);
}
void StorageAreaMap::didRemoveItem(uint64_t mapSeed, const String& key)
{
if (m_currentSeed != mapSeed)
return;
ASSERT(m_pendingValueChanges.contains(key));
m_pendingValueChanges.remove(key);
}
void StorageAreaMap::didClear(uint64_t mapSeed)
{
if (m_currentSeed != mapSeed)
return;
ASSERT(m_hasPendingClear);
m_hasPendingClear = false;
}
bool StorageAreaMap::shouldApplyChangeForKey(const String& key) const
{
if (!m_map)
return false;
if (m_pendingValueChanges.contains(key))
return false;
return true;
}
void StorageAreaMap::applyChange(const String& key, const String& newValue)
{
ASSERT(!m_map || m_map->hasOneRef());
if (m_hasPendingClear)
return;
if (!key) {
auto newMap = StorageMap::create(m_quotaInBytes);
for (auto& change : m_pendingValueChanges) {
auto& key = change.key;
String value = m_map->getItem(key);
if (!value) {
continue;
}
String oldValue;
newMap->setItemIgnoringQuota(key, oldValue);
}
m_map = WTFMove(newMap);
return;
}
if (!shouldApplyChangeForKey(key))
return;
if (!newValue) {
String oldValue;
m_map->removeItem(key, oldValue);
return;
}
m_map->setItemIgnoringQuota(key, newValue);
}
void StorageAreaMap::dispatchStorageEvent(const Optional<StorageAreaImplIdentifier>& storageAreaImplID, const String& key, const String& oldValue, const String& newValue, const String& urlString)
{
if (!storageAreaImplID) {
applyChange(key, newValue);
}
if (type() == StorageType::Session)
dispatchSessionStorageEvent(storageAreaImplID, key, oldValue, newValue, urlString);
else
dispatchLocalStorageEvent(storageAreaImplID, key, oldValue, newValue, urlString);
}
void StorageAreaMap::clearCache()
{
resetValues();
}
static Vector<RefPtr<Frame>> framesForEventDispatching(Page& page, SecurityOrigin& origin, StorageType storageType, const Optional<StorageAreaImplIdentifier>& storageAreaImplID)
{
Vector<RefPtr<Frame>> frames;
page.forEachDocument([&](auto& document) {
if (!document.securityOrigin().equal(&origin))
return;
auto* window = document.domWindow();
if (!window)
return;
Storage* storage = nullptr;
switch (storageType) {
case StorageType::Session:
storage = window->optionalSessionStorage();
break;
case StorageType::Local:
case StorageType::TransientLocal:
storage = window->optionalLocalStorage();
break;
}
if (!storage)
return;
auto& storageArea = static_cast<StorageAreaImpl&>(storage->area());
if (storageArea.identifier() == storageAreaImplID) {
return;
}
if (auto* frame = document.frame())
frames.append(frame);
});
return frames;
}
void StorageAreaMap::dispatchSessionStorageEvent(const Optional<StorageAreaImplIdentifier>& storageAreaImplID, const String& key, const String& oldValue, const String& newValue, const String& urlString)
{
auto* webPage = WebProcess::singleton().webPage(m_namespace.sessionStoragePageID());
if (!webPage)
return;
auto* page = webPage->corePage();
if (!page)
return;
auto frames = framesForEventDispatching(*page, m_securityOrigin, StorageType::Session, storageAreaImplID);
StorageEventDispatcher::dispatchSessionStorageEventsToFrames(*page, frames, key, oldValue, newValue, urlString, m_securityOrigin->data());
}
void StorageAreaMap::dispatchLocalStorageEvent(const Optional<StorageAreaImplIdentifier>& storageAreaImplID, const String& key, const String& oldValue, const String& newValue, const String& urlString)
{
ASSERT(isLocalStorage(type()));
Vector<RefPtr<Frame>> frames;
auto& pageGroup = *WebProcess::singleton().webPageGroup(m_namespace.pageGroupID())->corePageGroup();
for (auto* page : pageGroup.pages())
frames.appendVector(framesForEventDispatching(*page, m_securityOrigin, StorageType::Local, storageAreaImplID));
StorageEventDispatcher::dispatchLocalStorageEventsToFrames(pageGroup, frames, key, oldValue, newValue, urlString, m_securityOrigin->data());
}
void StorageAreaMap::connect()
{
if (m_mapID)
return;
switch (m_type) {
case StorageType::Local:
case StorageType::TransientLocal:
if (SecurityOrigin* topLevelOrigin = m_namespace.topLevelOrigin())
WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::StorageManagerSet::ConnectToTransientLocalStorageArea(WebProcess::singleton().sessionID(), m_namespace.storageNamespaceID(), topLevelOrigin->data(), m_securityOrigin->data()), Messages::StorageManagerSet::ConnectToTransientLocalStorageArea::Reply(m_mapID), 0);
else
WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::StorageManagerSet::ConnectToLocalStorageArea(WebProcess::singleton().sessionID(), m_namespace.storageNamespaceID(), m_securityOrigin->data()), Messages::StorageManagerSet::ConnectToLocalStorageArea::Reply(m_mapID), 0);
break;
case StorageType::Session:
WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::StorageManagerSet::ConnectToSessionStorageArea(WebProcess::singleton().sessionID(), m_namespace.storageNamespaceID(), m_securityOrigin->data()), Messages::StorageManagerSet::ConnectToSessionStorageArea::Reply(m_mapID), 0);
}
if (m_mapID)
WebProcess::singleton().registerStorageAreaMap(*this);
}
void StorageAreaMap::disconnect()
{
if (!m_mapID)
return;
resetValues();
WebProcess::singleton().unregisterStorageAreaMap(*this);
if (auto* networkProcessConnection = WebProcess::singleton().existingNetworkProcessConnection())
networkProcessConnection->connection().send(Messages::StorageManagerSet::DisconnectFromStorageArea(*m_mapID), 0);
m_mapID = { };
}
void StorageAreaMap::incrementUseCount()
{
++m_useCount;
}
void StorageAreaMap::decrementUseCount()
{
if (!--m_useCount)
m_namespace.destroyStorageAreaMap(*this);
}
}