Attachment #449344 for bug #235236

View Details Raw Unified Return to Bug 235236

| Differences between



2022-01-17  Sihui Liu  <sihui_liu@apple.com>

        Make LocalStorage prewarming async
        https://bugs.webkit.org/show_bug.cgi?id=235236

        Reviewed by NOBODY (OOPS!).

        * page/DOMWindow.cpp:
        (WebCore::DOMWindow::prewarmLocalStorageIfNecessary):
        * page/Frame.cpp:
        (WebCore::Frame::didPrewarmLocalStorage): Deleted.
        (WebCore::Frame::mayPrewarmLocalStorage const): Deleted.
        * page/Frame.h:
        * storage/StorageArea.h:
        (WebCore::StorageArea::prewarm):
        * storage/StorageType.h:

2022-01-17  Carlos Garcia Campos  <cgarcia@igalia.com>

        [GTK][a11y] Stop using isolated tree for the ATSPI implementation



2022-01-17  Sihui Liu  <sihui_liu@apple.com>

        Make LocalStorage prewarming async
        https://bugs.webkit.org/show_bug.cgi?id=235236

        Reviewed by NOBODY (OOPS!).

        StorageAreaMap in web process needs to sync with a remote StorageArea in network process before it performs any
        Web Storage operation. To connect to remote StorageArea, StorageAreaMap currently sends out two sync messages:
        1. ConnectTo*StorageArea: for getting the remote StorageAreaIdentifier
        2. getValues: for getting the content of StorageArea
        We can merge these two messages into one message: ConnectToStorageAreaSync, and return both remote 
        StorageAreaIdentifier and content in its reply. This way, web process will not be blocked twice.

        To reduce the wait time for connecting to a local StorageArea, we would prewarm LocalStorage by creating its 
        StorageAreaMap ahead and making it connected (r247555), but we don't actually need StorageAreaMap to be ready 
        for operation at this time. Therefore, a new async message ConnectToStorageArea is added to be used for 
        prewarming.

        If LocalStorage is used immediately after prewarming, a StorageAreaMap may send ConnectToStorageAreaSync before 
        receiving the reply of ConnectToStorageArea. In this case, StorageAreaMap would handle ConnectToStorageAreaSync 
        reply before ConnectToStorageArea reply (due to the priority of sync message), and also before other async 
        messages (DispatchStorageEvent / ClearCache) that are sent from network process earlier before the sync reply.
        To solve this, we use a message identifier to indicate the order of messages sent from network process, so
        StorageAreaMap can ignore previous messages when it is already synced with a more recent version of StorageArea.

        * NetworkProcess/WebStorage/StorageArea.cpp:
        (WebKit::StorageArea::clear):
        (WebKit::StorageArea::dispatchEvents const):
        * NetworkProcess/storage/LocalStorageManager.cpp:
        (WebKit::LocalStorageManager::connectToLocalStorageArea):
        (WebKit::LocalStorageManager::connectToTransientLocalStorageArea):
        * NetworkProcess/storage/LocalStorageManager.h:
        * NetworkProcess/storage/NetworkStorageManager.cpp:
        (WebKit::NetworkStorageManager::connectToStorageArea):
        (WebKit::NetworkStorageManager::connectToStorageAreaSync):
        (WebKit::NetworkStorageManager::connectToLocalStorageArea): Deleted.
        (WebKit::NetworkStorageManager::connectToTransientLocalStorageArea): Deleted.
        (WebKit::NetworkStorageManager::connectToSessionStorageArea): Deleted.
        (WebKit::NetworkStorageManager::getValues): Deleted.
        * NetworkProcess/storage/NetworkStorageManager.h:
        * NetworkProcess/storage/NetworkStorageManager.messages.in:
        * NetworkProcess/storage/SessionStorageManager.cpp:
        (WebKit::SessionStorageManager::connectToSessionStorageArea):
        * NetworkProcess/storage/SessionStorageManager.h:
        * NetworkProcess/storage/StorageAreaBase.cpp:
        (WebKit::StorageAreaBase::nextMessageIdentifier):
        (WebKit::StorageAreaBase::StorageAreaBase):
        (WebKit::StorageAreaBase::addListener):
        (WebKit::StorageAreaBase::notifyListenersAboutClear):
        (WebKit::StorageAreaBase::dispatchEvents const):
        * NetworkProcess/storage/StorageAreaBase.h:
        * Scripts/webkit/messages.py:
        (types_that_cannot_be_forward_declared):
        (headers_for_type):
        * WebKit.xcodeproj/project.pbxproj:
        * WebProcess/Network/NetworkProcessConnection.cpp:
        (WebKit::NetworkProcessConnection::didReceiveMessage):
        * WebProcess/WebProcess.cpp:
        (WebKit::WebProcess::networkProcessConnectionClosed):
        (WebKit::WebProcess::registerStorageAreaMap):
        (WebKit::WebProcess::unregisterStorageAreaMap):
        (WebKit::WebProcess::storageAreaMap const):
        * WebProcess/WebProcess.h:
        * WebProcess/WebStorage/StorageAreaImpl.cpp:
        (WebKit::StorageAreaImpl::prewarm):
        (WebKit::StorageAreaImpl::incrementAccessCount): Deleted.
        (WebKit::StorageAreaImpl::decrementAccessCount): Deleted.
        (WebKit::StorageAreaImpl::closeDatabaseIfIdle): Deleted.
        * WebProcess/WebStorage/StorageAreaImpl.h:
        * WebProcess/WebStorage/StorageAreaMap.cpp:
        (WebKit::StorageAreaMap::StorageAreaMap):
        (WebKit::StorageAreaMap::~StorageAreaMap):
        (WebKit::StorageAreaMap::setItem):
        (WebKit::StorageAreaMap::removeItem):
        (WebKit::StorageAreaMap::clear):
        (WebKit::StorageAreaMap::ensureMap):
        (WebKit::StorageAreaMap::dispatchStorageEvent):
        (WebKit::StorageAreaMap::clearCache):
        (WebKit::StorageAreaMap::sendConnectMessage):
        (WebKit::StorageAreaMap::connectSync):
        (WebKit::StorageAreaMap::connect):
        (WebKit::StorageAreaMap::didConnect):
        (WebKit::StorageAreaMap::disconnect):
        * WebProcess/WebStorage/StorageAreaMap.h:
        * WebProcess/WebStorage/StorageAreaMap.messages.in:
        * WebProcess/WebStorage/StorageAreaMapIdentifier.h: Added.

2022-01-17  Kimmo Kinnunen  <kkinnunen@apple.com>

        Frequent GPU process jetsams due to RemoteRenderingBackendProxy not claiming ownership of SharedMemory buffers



    if (!page || page->usesEphemeralSession())
        return;

    if (!page->mainFrame().mayPrewarmLocalStorage())
        return;

    // This eagerly constructs the StorageArea, which will load items from disk.
    auto localStorageResult = this->localStorage();
    if (localStorageResult.hasException())

    if (!localStorage)
        return;

    localStorage->area().prewarm();
}

DOMWindow::~DOMWindow()



        tree().removeChild(*child);
}

void Frame::didPrewarmLocalStorage()
{
    ASSERT(isMainFrame());
    ASSERT(m_localStoragePrewarmingCount < maxlocalStoragePrewarmingCount);
    ++m_localStoragePrewarmingCount;
}

bool Frame::mayPrewarmLocalStorage() const
{
    ASSERT(isMainFrame());
    return m_localStoragePrewarmingCount < maxlocalStoragePrewarmingCount;
}

FloatSize Frame::screenSize() const
{
    if (!m_overrideScreenSize.isEmpty())



    void resumeActiveDOMObjectsAndAnimations();
    bool activeDOMObjectsAndAnimationsSuspended() const { return m_activeDOMObjectsAndAnimationsSuspendedCount > 0; }

    void didPrewarmLocalStorage();
    bool mayPrewarmLocalStorage() const;

    enum class InvalidateContentEventRegionsReason { Layout, EventHandlerChange };
    void invalidateContentEventRegionsIfNeeded(InvalidateContentEventRegionsReason);


    unsigned m_navigationDisableCount { 0 };
    unsigned m_selfOnlyRefCount { 0 };
    bool m_hasHadUserInteraction { false };
    unsigned m_localStoragePrewarmingCount { 0 };

    FloatSize m_overrideScreenSize;


Lines 58-63 public: a/Source/WebCore/storage/StorageArea.h_sec1
- a/Source/WebCore/storage/StorageArea.h +1 lines
58	virtual void incrementAccessCount() { }	58	virtual void incrementAccessCount() { }
59	virtual void decrementAccessCount() { }	59	virtual void decrementAccessCount() { }
60	virtual void closeDatabaseIfIdle() { }	60	virtual void closeDatabaseIfIdle() { }
		61	virtual void prewarm() { }
61	};	62	};
62		63
63	} // namespace WebCore	64	} // namespace WebCore



}

} // namespace WebCore

namespace WTF {

template<> struct EnumTraits<WebCore::StorageType> {
    using values = EnumValues<
        WebCore::StorageType,
        WebCore::StorageType::Session,
        WebCore::StorageType::Local,
        WebCore::StorageType::TransientLocal
    >;
};

} // namespace WTF



    }

    for (auto& listenerUniqueID : m_eventListeners)
        IPC::Connection::send(listenerUniqueID, Messages::StorageAreaMap::ClearCache(0), m_identifier.toUInt64());
}

LocalStorageDatabase& StorageArea::ensureDatabase() const

    ASSERT(storageAreaImplID);
    for (auto& listenerUniqueID : m_eventListeners) {
        auto optionalStorageAreaImplID = listenerUniqueID == sourceConnection ? std::make_optional(storageAreaImplID) : std::nullopt;
        IPC::Connection::send(listenerUniqueID, Messages::StorageAreaMap::DispatchStorageEvent(optionalStorageAreaImplID, key, oldValue, newValue, urlString, 0), m_identifier.toUInt64());
    }
}




    m_transientStorageArea = nullptr;
}

StorageAreaIdentifier LocalStorageManager::connectToLocalStorageArea(IPC::Connection::UniqueID connection, StorageAreaMapIdentifier sourceIdentifier, const WebCore::ClientOrigin& origin, Ref<WorkQueue>&& workQueue)
{
    if (!m_localStorageArea) {
        if (!m_path.isEmpty())

    }

    ASSERT(m_path.isEmpty() || m_localStorageArea->type() == StorageAreaBase::Type::SQLite);
    m_localStorageArea->addListener(connection, sourceIdentifier);
    return m_localStorageArea->identifier();
}

StorageAreaIdentifier LocalStorageManager::connectToTransientLocalStorageArea(IPC::Connection::UniqueID connection, StorageAreaMapIdentifier sourceIdentifier, const WebCore::ClientOrigin& origin)
{
    if (!m_transientStorageArea) {
        m_transientStorageArea = makeUnique<MemoryStorageArea>(origin, StorageAreaBase::StorageType::Local);

    }

    ASSERT(m_transientStorageArea->type() == StorageAreaBase::Type::Memory);
    m_transientStorageArea->addListener(connection, sourceIdentifier);
    return m_transientStorageArea->identifier();
}





#include "Connection.h"
#include "StorageAreaIdentifier.h"
#include "StorageAreaMapIdentifier.h"
#include <wtf/WorkQueue.h>

namespace WebCore {

    void syncLocalStorage();
    void connectionClosed(IPC::Connection::UniqueID);

    StorageAreaIdentifier connectToLocalStorageArea(IPC::Connection::UniqueID, StorageAreaMapIdentifier, const WebCore::ClientOrigin&, Ref<WorkQueue>&&);
    StorageAreaIdentifier connectToTransientLocalStorageArea(IPC::Connection::UniqueID, StorageAreaMapIdentifier, const WebCore::ClientOrigin&);
    void disconnectFromStorageArea(IPC::Connection::UniqueID, StorageAreaIdentifier);

private:



    });
}

void NetworkStorageManager::connectToStorageArea(IPC::Connection& connection, WebCore::StorageType type, StorageAreaMapIdentifier sourceIdentifier, StorageNamespaceIdentifier namespaceIdentifier, const WebCore::ClientOrigin& origin, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&& completionHandler)
{
    ASSERT(!RunLoop::isMain());

    auto connectionIdentifier = connection.uniqueID();
    auto& originStorageManager = localOriginStorageManager(origin);
    StorageAreaIdentifier resultIdentifier;
    switch (type) {
    case WebCore::StorageType::Local:
        resultIdentifier = originStorageManager.localStorageManager(*m_storageAreaRegistry).connectToLocalStorageArea(connectionIdentifier, sourceIdentifier, origin, m_queue.copyRef());
        break;
    case WebCore::StorageType::TransientLocal:
        resultIdentifier = originStorageManager.localStorageManager(*m_storageAreaRegistry).connectToTransientLocalStorageArea(connectionIdentifier, sourceIdentifier, origin);
        break;
    case WebCore::StorageType::Session:
        resultIdentifier = originStorageManager.sessionStorageManager(*m_storageAreaRegistry).connectToSessionStorageArea(connectionIdentifier, sourceIdentifier, origin, namespaceIdentifier);
    }

    if (auto storageArea = m_storageAreaRegistry->getStorageArea(resultIdentifier))
        return completionHandler(resultIdentifier, storageArea->allItems(), StorageAreaBase::nextMessageIdentifier());

    return completionHandler(resultIdentifier, HashMap<String, String> { }, StorageAreaBase::nextMessageIdentifier());
}

void NetworkStorageManager::connectToStorageAreaSync(IPC::Connection& connection, WebCore::StorageType type, StorageAreaMapIdentifier sourceIdentifier, StorageNamespaceIdentifier namespaceIdentifier, const WebCore::ClientOrigin& origin, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&& completionHandler)
{
    connectToStorageArea(connection, type, sourceIdentifier, namespaceIdentifier, origin, WTFMove(completionHandler));
    completionHandler(localOriginStorageManager(origin).sessionStorageManager(*m_storageAreaRegistry).connectToSessionStorageArea(connection.uniqueID(), origin, identifier));
}

void NetworkStorageManager::disconnectFromStorageArea(IPC::Connection& connection, StorageAreaIdentifier identifier)

    }
}

void NetworkStorageManager::getValues(StorageAreaIdentifier identifier, CompletionHandler<void(const HashMap<String, String>&)>&& completionHandler)
{
    ASSERT(!RunLoop::isMain());

    if (auto storageArea = m_storageAreaRegistry->getStorageArea(identifier))
        return completionHandler(storageArea->allItems());
    
    return completionHandler({ });
}

void NetworkStorageManager::setItem(IPC::Connection& connection, StorageAreaIdentifier identifier, StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String&& key, String&& value, String&& urlString)
{
    ASSERT(!RunLoop::isMain());



#include "OriginStorageManager.h"
#include "StorageAreaIdentifier.h"
#include "StorageAreaImplIdentifier.h"
#include "StorageAreaMapIdentifier.h"
#include "StorageNamespaceIdentifier.h"
#include "WebsiteData.h"
#include <WebCore/ClientOrigin.h>


namespace WebCore {
struct ClientOrigin;
enum class StorageType : uint8_t;
}

namespace WebKit {

    void getHandle(IPC::Connection&, WebCore::FileSystemHandleIdentifier, String&& name, CompletionHandler<void(Expected<std::pair<WebCore::FileSystemHandleIdentifier, bool>, FileSystemStorageError>)>&&);
    
    // Message handlers for WebStorage.
    void connectToStorageArea(IPC::Connection&, WebCore::StorageType, StorageAreaMapIdentifier, StorageNamespaceIdentifier, const WebCore::ClientOrigin&, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&&);
    void connectToStorageAreaSync(IPC::Connection&, WebCore::StorageType, StorageAreaMapIdentifier, StorageNamespaceIdentifier, const WebCore::ClientOrigin&, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&&);
    void connectToSessionStorageArea(IPC::Connection&, StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, CompletionHandler<void(StorageAreaIdentifier)>&&);
    void disconnectFromStorageArea(IPC::Connection&, StorageAreaIdentifier);
    void cloneSessionStorageNamespace(IPC::Connection&, StorageNamespaceIdentifier, StorageNamespaceIdentifier);
    void getValues(StorageAreaIdentifier, CompletionHandler<void(const HashMap<String, String>&)>&&);
    void setItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& key, String&& value, String&& urlString);
    void removeItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& key, String&& urlString);
    void clear(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& urlString);



    GetHandleNames(WebCore::FileSystemHandleIdentifier identifier) -> (Expected<Vector<String>, WebKit::FileSystemStorageError> result) Async
    GetHandle(WebCore::FileSystemHandleIdentifier identifier, String name) -> (Expected<std::pair<WebCore::FileSystemHandleIdentifier, bool>, WebKit::FileSystemStorageError> result) Async WantsConnection

    ConnectToStorageArea(WebCore::StorageType type, WebKit::StorageAreaMapIdentifier sourceIdentifier, WebKit::StorageNamespaceIdentifier namespaceIdentifier, struct WebCore::ClientOrigin origin) -> (WebKit::StorageAreaIdentifier identifier, HashMap<String, String> items, uint64_t messageIdentifier) Async WantsConnection
    ConnectToStorageAreaSync(WebCore::StorageType type, WebKit::StorageAreaMapIdentifier sourceIdentifier, WebKit::StorageNamespaceIdentifier namespaceIdentifier, struct WebCore::ClientOrigin origin) -> (WebKit::StorageAreaIdentifier identifier, HashMap<String, String> items, uint64_t messageIdentifier) Synchronous WantsConnection
    ConnectToSessionStorageArea(WebKit::StorageNamespaceIdentifier storageNamespaceID, struct WebCore::SecurityOriginData securityOriginData) -> (WebKit::StorageAreaIdentifier identifier) Synchronous WantsConnection
    DisconnectFromStorageArea(WebKit::StorageAreaIdentifier identifier) WantsConnection
    CloneSessionStorageNamespace(WebKit::StorageNamespaceIdentifier fromStorageNamespaceID, WebKit::StorageNamespaceIdentifier toStorageNamespaceID) WantsConnection
    GetValues(WebKit::StorageAreaIdentifier identifier) -> (HashMap<String, String> values) Synchronous
    SetItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String key, String value, String urlString) WantsConnection
    RemoveItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String key, String urlString) WantsConnection
    Clear(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String urlString) WantsConnection



    return identifier;
}

StorageAreaIdentifier SessionStorageManager::connectToSessionStorageArea(IPC::Connection::UniqueID connection, StorageAreaMapIdentifier sourceIdentifier, const WebCore::ClientOrigin& origin, StorageNamespaceIdentifier namespaceIdentifier)
{
    auto identifier = m_storageAreasByNamespace.get(namespaceIdentifier);
    if (!identifier.isValid()) {

    if (!storageArea)
        return StorageAreaIdentifier { };

    storageArea->addListener(connection, sourceIdentifier);

    return identifier;
}





#include "Connection.h"
#include "StorageAreaIdentifier.h"
#include "StorageAreaMapIdentifier.h"
#include "StorageNamespaceIdentifier.h"

namespace WebCore {

    void clearData();
    void connectionClosed(IPC::Connection::UniqueID);

    StorageAreaIdentifier connectToSessionStorageArea(IPC::Connection::UniqueID, StorageAreaMapIdentifier, const WebCore::ClientOrigin&, StorageNamespaceIdentifier);
    void disconnectFromStorageArea(IPC::Connection::UniqueID, StorageAreaIdentifier);
    void cloneStorageArea(IPC::Connection::UniqueID, StorageNamespaceIdentifier, StorageNamespaceIdentifier);





namespace WebKit {

uint64_t StorageAreaBase::nextMessageIdentifier()
{
    static std::atomic<uint64_t> currenIdentifier(0);
    return ++currenIdentifier;
}

StorageAreaBase::StorageAreaBase(unsigned quota, const WebCore::ClientOrigin& origin)
    : m_identifier(StorageAreaIdentifier::generateThreadSafe())
    , m_quota(quota)
    , m_origin(origin)
{


StorageAreaBase::~StorageAreaBase() = default;

void StorageAreaBase::addListener(IPC::Connection::UniqueID connection, StorageAreaMapIdentifier identifier)
{
    ASSERT(!m_listeners.contains(connection) || m_listeners.get(connection) == identifier);

    m_listeners.set(connection, identifier);
}

void StorageAreaBase::removeListener(IPC::Connection::UniqueID connection)


void StorageAreaBase::notifyListenersAboutClear()
{
    for (auto& [connection, identifier] : m_listeners)
        IPC::Connection::send(connection, Messages::StorageAreaMap::ClearCache(StorageAreaBase::nextMessageIdentifier()), identifier.toUInt64());
}

void StorageAreaBase::dispatchEvents(IPC::Connection::UniqueID sourceConnection, StorageAreaImplIdentifier sourceImplIdentifier, const String& key, const String& oldValue, const String& newValue, const String& urlString) const
{
    ASSERT(sourceImplIdentifier);

    for (auto& [connection, identifier] : m_listeners) {
        std::optional<StorageAreaImplIdentifier> implIdentifier;
        if (connection == sourceConnection)
            implIdentifier = sourceImplIdentifier;
        IPC::Connection::send(connection, Messages::StorageAreaMap::DispatchStorageEvent(implIdentifier, key, oldValue, newValue, urlString, StorageAreaBase::nextMessageIdentifier()), identifier.toUInt64());
    }
}




#include "Connection.h"
#include "StorageAreaIdentifier.h"
#include "StorageAreaImplIdentifier.h"
#include "StorageAreaMapIdentifier.h"
#include <WebCore/ClientOrigin.h>
#include <wtf/WeakPtr.h>


    WTF_MAKE_NONCOPYABLE(StorageAreaBase);
    WTF_MAKE_FAST_ALLOCATED;
public:
    static uint64_t nextMessageIdentifier();
    virtual ~StorageAreaBase();

    enum class Type : bool { SQLite, Memory };

    StorageAreaIdentifier identifier() const { return m_identifier; }
    WebCore::ClientOrigin origin() const { return m_origin; }
    unsigned quota() const { return m_quota; }
    void addListener(IPC::Connection::UniqueID, StorageAreaMapIdentifier);
    void removeListener(IPC::Connection::UniqueID);
    bool hasListeners() const;
    void notifyListenersAboutClear();

    StorageAreaIdentifier m_identifier;
    unsigned m_quota;
    WebCore::ClientOrigin m_origin;
    HashMap<IPC::Connection::UniqueID, StorageAreaMapIdentifier> m_listeners;
};

} // namespace WebKit



        'WebCore::SleepDisablerIdentifier',
        'WebCore::SourceBufferAppendMode',
        'WebCore::SpeechRecognitionConnectionClientIdentifier',
        'WebCore::StorageType',
        'WebCore::UserMediaRequestIdentifier',
        'WebCore::WebLockIdentifier',
        'WebCore::WebSocketIdentifier',

        'WebKit::SampleBufferDisplayLayerIdentifier',
        'WebKit::StorageAreaIdentifier',
        'WebKit::StorageAreaImplIdentifier',
        'WebKit::StorageAreaMapIdentifier',
        'WebKit::StorageNamespaceIdentifier',
        'WebKit::TapIdentifier',
        'WebKit::TextCheckerRequestID',



		93AB9B4E257567E20098B10E /* SpeechRecognitionRemoteRealtimeMediaSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 93AB9B422574928C0098B10E /* SpeechRecognitionRemoteRealtimeMediaSource.h */; };
		93AB9B552575A2760098B10E /* SpeechRecognitionRealtimeMediaSourceManagerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93AB9B4F257589110098B10E /* SpeechRecognitionRealtimeMediaSourceManagerMessageReceiver.cpp */; };
		93AB9B562575A28B0098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93AB9B51257589110098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessageReceiver.cpp */; };
		93AEC161278F8CD30066666F /* StorageAreaMapIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 93AEC160278F8CD20066666F /* StorageAreaMapIdentifier.h */; };
		93B0A67526D5ADCF00AA21E4 /* WebPermissionController.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B0A67426D5A72E00AA21E4 /* WebPermissionController.h */; };
		93B2614D227D149E00B97A76 /* StorageManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B26149227D147200B97A76 /* StorageManager.h */; };
		93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B26145227D147000B97A76 /* LocalStorageDatabase.h */; };

		93AB9B52257589120098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessagesReplies.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRemoteRealtimeMediaSourceManagerMessagesReplies.h; sourceTree = "<group>"; };
		93AB9B53257589120098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRemoteRealtimeMediaSourceManagerMessages.h; sourceTree = "<group>"; };
		93AB9B54257589120098B10E /* SpeechRecognitionRealtimeMediaSourceManagerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRealtimeMediaSourceManagerMessages.h; sourceTree = "<group>"; };
		93AEC160278F8CD20066666F /* StorageAreaMapIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageAreaMapIdentifier.h; sourceTree = "<group>"; };
		93B0A67326D5A72E00AA21E4 /* WebPermissionController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPermissionController.cpp; sourceTree = "<group>"; };
		93B0A67426D5A72E00AA21E4 /* WebPermissionController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPermissionController.h; sourceTree = "<group>"; };
		93B26145227D147000B97A76 /* LocalStorageDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalStorageDatabase.h; sourceTree = "<group>"; };

				1ACECD2217162DB1001FC9EF /* StorageAreaMap.cpp */,
				1ACECD2317162DB1001FC9EF /* StorageAreaMap.h */,
				1A334DEA16DE8B68006A8E38 /* StorageAreaMap.messages.in */,
				93AEC160278F8CD20066666F /* StorageAreaMapIdentifier.h */,
				465F4E05230B2E7C003CEDB7 /* StorageNamespaceIdentifier.h */,
				1A17635416B1D5D000D88FD6 /* StorageNamespaceImpl.cpp */,
				1A17635516B1D5D000D88FD6 /* StorageNamespaceImpl.h */,

				93E799DC276121080074008A /* StorageAreaBase.h in Headers */,
				1AD3306F16B1D991004F60E7 /* StorageAreaImpl.h in Headers */,
				1ACECD2517162DB1001FC9EF /* StorageAreaMap.h in Headers */,
				93AEC161278F8CD30066666F /* StorageAreaMapIdentifier.h in Headers */,
				1A334DEE16DE8F88006A8E38 /* StorageAreaMapMessages.h in Headers */,
				93E799C7276027460074008A /* StorageAreaRegistry.h in Headers */,
				93B2614D227D149E00B97A76 /* StorageManager.h in Headers */,

Lines 117-123 void NetworkProcessConnection::didReceiveMessage(IPC::Connection& connection, IP a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp_sec1
- a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp -1 / +1 lines
117	return;	117	return;
118	}	118	}
119	if (decoder.messageReceiverName() == Messages::StorageAreaMap::messageReceiverName()) {	119	if (decoder.messageReceiverName() == Messages::StorageAreaMap::messageReceiverName()) {
120	if (auto* storageAreaMap = WebProcess::singleton().storageAreaMap(makeObjectIdentifier<StorageAreaIdentifierType>(decoder.destinationID())))	120	if (auto storageAreaMap = WebProcess::singleton().storageAreaMap(makeObjectIdentifier<StorageAreaMapIdentifierType>(decoder.destinationID())))
121	storageAreaMap->didReceiveMessage(connection, decoder);	121	storageAreaMap->didReceiveMessage(connection, decoder);
122	return;	122	return;
123	}	123	}



    ASSERT(m_networkProcessConnection);
    ASSERT_UNUSED(connection, m_networkProcessConnection == connection);

    for (auto key : copyToVector(m_storageAreaMaps.keys()))
        m_storageAreaMaps.get(key)->disconnect();

    for (auto& page : m_pageMap.values()) {
        auto idbConnection = page->corePage()->optionalIDBConnection();


void WebProcess::registerStorageAreaMap(StorageAreaMap& storageAreaMap)
{
    auto identifier = storageAreaMap.identifier();
    ASSERT(!m_storageAreaMaps.contains(identifier));
    m_storageAreaMaps.add(identifier, storageAreaMap);
}

void WebProcess::unregisterStorageAreaMap(StorageAreaMap& storageAreaMap)
{
    auto identifier = storageAreaMap.identifier();
    ASSERT(m_storageAreaMaps.contains(identifier));
    ASSERT(m_storageAreaMaps.get(identifier).get() == &storageAreaMap);
    m_storageAreaMaps.remove(identifier);
}

WeakPtr<StorageAreaMap> WebProcess::storageAreaMap(StorageAreaMapIdentifier identifier) const
{
    return m_storageAreaMaps.get(identifier);
}



#include "CacheModel.h"
#include "IdentifierTypes.h"
#include "SandboxExtension.h"
#include "StorageAreaMapIdentifier.h"
#include "TextCheckerState.h"
#include "UserContentControllerIdentifier.h"
#include "ViewUpdateDispatcher.h"


    void registerStorageAreaMap(StorageAreaMap&);
    void unregisterStorageAreaMap(StorageAreaMap&);
    WeakPtr<StorageAreaMap> storageAreaMap(StorageAreaMapIdentifier) const;

#if PLATFORM(COCOA)
    RetainPtr<CFDataRef> sourceApplicationAuditData() const;

    HashCountedSet<WebCore::ServiceWorkerRegistrationIdentifier> m_swRegistrationCounts;
#endif

    HashMap<StorageAreaMapIdentifier, WeakPtr<StorageAreaMap>> m_storageAreaMaps;
    
    // Prewarmed WebProcesses do not have an associated sessionID yet, which is why this is an optional.
    // By the time the WebProcess gets a WebPage, it is guaranteed to have a sessionID.



    return 0;
}

void StorageAreaImpl::prewarm()
{
    if (m_storageAreaMap)
        m_storageAreaMap->connect();

void StorageAreaImpl::decrementAccessCount()
{
    // Storage access is handled in the network process, so there's nothing to do here.
}

void StorageAreaImpl::closeDatabaseIfIdle()
{
    // FIXME: Implement this.
    ASSERT_NOT_REACHED();
}

} // namespace WebKit



    bool contains(const String& key) override;
    WebCore::StorageType storageType() const override;
    size_t memoryBytesUsedByCache() override;
    void prewarm() final;
    void decrementAccessCount() override;
    void closeDatabaseIfIdle() override;

    Identifier m_identifier;
    WeakPtr<StorageAreaMap> m_storageAreaMap;



using namespace WebCore;

StorageAreaMap::StorageAreaMap(StorageNamespaceImpl& storageNamespace, Ref<WebCore::SecurityOrigin>&& securityOrigin)
    : m_identifier(StorageAreaMapIdentifier::generate())
    , m_namespace(storageNamespace)
    , m_securityOrigin(WTFMove(securityOrigin))
    , m_quotaInBytes(storageNamespace.quotaInBytes())
    , m_type(storageNamespace.storageType())
{
    WebProcess::singleton().registerStorageAreaMap(*this);
}

StorageAreaMap::~StorageAreaMap()
{
    disconnect();
    WebProcess::singleton().unregisterStorageAreaMap(*this);
}

unsigned StorageAreaMap::length()


    m_pendingValueChanges.add(key);

    if (m_remoteAreaIdentifier)
        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::SetItem(*m_remoteAreaIdentifier, 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");
}


    m_pendingValueChanges.add(key);

    if (m_remoteAreaIdentifier)
        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::RemoveItem(*m_remoteAreaIdentifier, 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)
{
    connectSync();

    resetValues();

    m_hasPendingClear = true;
    m_map = makeUnique<StorageMap>(m_quotaInBytes);

    if (m_remoteAreaIdentifier)
        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::Clear(*m_remoteAreaIdentifier, sourceArea->identifier(), m_currentSeed, sourceFrame->document()->url().string()), 0);
    else
        RELEASE_LOG_ERROR(Storage, "StorageAreaMap::clear failed because storage map ID is invalid");
}


StorageMap& StorageAreaMap::ensureMap()
{
    connectSync();

    if (!m_map)
        m_map = makeUnique<StorageMap>(m_quotaInBytes);

        if (m_mapID) {
            // We need to use a IPC::UnboundedSynchronousIPCScope to prevent UIProcess hangs in case we receive a synchronous IPC from the UIProcess while we're waiting for a response
            // from our StorageManagerSet::GetValues() IPC. This IPC may be very slow because it may need to fetch the values from disk and there may be a lot of data.
            IPC::UnboundedSynchronousIPCScope unboundedSynchronousIPCScope;
            HashMap<String, String> values;
            WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::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;
}


    m_map->setItemIgnoringQuota(key, newValue);
}

void StorageAreaMap::dispatchStorageEvent(const std::optional<StorageAreaImplIdentifier>& storageAreaImplID, const String& key, const String& oldValue, const String& newValue, const String& urlString, uint64_t messageIdentifier)
{
    if (messageIdentifier < m_lastHandledMessageIdentifier)
        return;

    m_lastHandledMessageIdentifier = messageIdentifier;
    if (!storageAreaImplID) {
        // This storage event originates from another process so we need to apply the change to our storage area map.
        applyChange(key, newValue);

        dispatchLocalStorageEvent(storageAreaImplID, key, oldValue, newValue, urlString);
}

void StorageAreaMap::clearCache(uint64_t messageIdentifier)
{
    if (messageIdentifier < m_lastHandledMessageIdentifier)
        return;

    m_lastHandledMessageIdentifier = messageIdentifier;
    resetValues();
}


    StorageEventDispatcher::dispatchLocalStorageEventsToFrames(pageGroup, frames, key, oldValue, newValue, urlString, m_securityOrigin->data());
}

void StorageAreaMap::sendConnectMessage(SendMode mode)
{
    auto& ipcConnection = WebProcess::singleton().ensureNetworkProcessConnection().connection();
    auto namespaceIdentifier = m_namespace.storageNamespaceID();
    auto originData = m_securityOrigin->data();
    auto topOriginData = m_namespace.topLevelOrigin() ? m_namespace.topLevelOrigin()->data() : originData;
    auto origin = WebCore::ClientOrigin { topOriginData, originData };
    auto type = m_type;
    if ((type == StorageType::Local || type == StorageType::TransientLocal) && m_namespace.topLevelOrigin())
        type = StorageType::TransientLocal;

    if (mode == SendMode::Sync) {
        StorageAreaIdentifier remoteAreaIdentifier;
        HashMap<String, String> items;
        uint64_t messageIdentifier;
        ipcConnection.sendSync(Messages::NetworkStorageManager::ConnectToStorageAreaSync(type, m_identifier, namespaceIdentifier, origin), Messages::NetworkStorageManager::ConnectToStorageAreaSync::Reply(remoteAreaIdentifier, items, messageIdentifier), 0);
        didConnect(remoteAreaIdentifier, WTFMove(items), messageIdentifier);
        return;
    }

    auto completionHandler = [this, weakThis = WeakPtr { *this }, weakConnection = WeakPtr { ipcConnection }](auto remoteAreaIdentifier, auto items, auto messageIdentifier) mutable {
        if (weakThis)
            return didConnect(remoteAreaIdentifier, WTFMove(items), messageIdentifier);

        if (weakConnection && remoteAreaIdentifier.isValid())
            weakConnection->send(Messages::NetworkStorageManager::DisconnectFromStorageArea(remoteAreaIdentifier), 0);
    };

    ipcConnection.sendWithAsyncReply(Messages::NetworkStorageManager::ConnectToStorageArea(type, m_identifier, namespaceIdentifier, origin), WTFMove(completionHandler));
}

void StorageAreaMap::connectSync()
{
    if (m_remoteAreaIdentifier)
        return;

    sendConnectMessage(SendMode::Sync);
}

void StorageAreaMap::connect()
{
    if (m_remoteAreaIdentifier)
        return;

    sendConnectMessage(SendMode::Async);
}
    case StorageType::Local:
    case StorageType::TransientLocal:
        if (SecurityOrigin* topLevelOrigin = m_namespace.topLevelOrigin())
            WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::ConnectToTransientLocalStorageArea(m_namespace.storageNamespaceID(), topLevelOrigin->data(), m_securityOrigin->data()), Messages::NetworkStorageManager::ConnectToTransientLocalStorageArea::Reply(mapID), 0);
        else
            WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::ConnectToLocalStorageArea(m_namespace.storageNamespaceID(), m_securityOrigin->data()), Messages::NetworkStorageManager::ConnectToLocalStorageArea::Reply(mapID), 0);
        break;
    case StorageType::Session:
        WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::ConnectToSessionStorageArea(m_namespace.storageNamespaceID(), m_securityOrigin->data()), Messages::NetworkStorageManager::ConnectToSessionStorageArea::Reply(mapID), 0);
    }

void StorageAreaMap::didConnect(StorageAreaIdentifier remoteAreaIdentifier, HashMap<String, String>&& items, uint64_t messageIdentifier)
{
    if (messageIdentifier < m_lastHandledMessageIdentifier)
        return;

    m_lastHandledMessageIdentifier = messageIdentifier;
    if (!remoteAreaIdentifier.isValid())
        return;

    m_remoteAreaIdentifier = remoteAreaIdentifier;
    m_map = makeUnique<StorageMap>(m_quotaInBytes);
    m_map->importItems(WTFMove(items));
}

void StorageAreaMap::disconnect()
{
    if (!m_remoteAreaIdentifier)
        return;

    resetValues();
    WebProcess::singleton().unregisterStorageAreaMap(*this);

    if (auto* networkProcessConnection = WebProcess::singleton().existingNetworkProcessConnection())
        networkProcessConnection->connection().send(Messages::NetworkStorageManager::DisconnectFromStorageArea(*m_remoteAreaIdentifier), 0);

    m_remoteAreaIdentifier = { };
    m_lastHandledMessageIdentifier = 0;
}

void StorageAreaMap::incrementUseCount()



#include "MessageReceiver.h"
#include "StorageAreaIdentifier.h"
#include "StorageAreaImplIdentifier.h"
#include "StorageAreaMapIdentifier.h"
#include <WebCore/SecurityOrigin.h>
#include <WebCore/StorageArea.h>
#include <wtf/Forward.h>

    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;

    const WebCore::SecurityOrigin& securityOrigin() const { return m_securityOrigin.get(); }
    StorageAreaMapIdentifier identifier() const { return m_identifier; }

    void connect();
    void disconnect();

    void incrementUseCount();

    void didRemoveItem(uint64_t mapSeed, const String& key);
    void didClear(uint64_t mapSeed);

    void dispatchStorageEvent(const std::optional<StorageAreaImplIdentifier>& sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString, uint64_t messageIdentifier);
    void clearCache(uint64_t messageIdentifier);

    void resetValues();
    WebCore::StorageMap& ensureMap();

    void dispatchSessionStorageEvent(const std::optional<StorageAreaImplIdentifier>&, const String& key, const String& oldValue, const String& newValue, const String& urlString);
    void dispatchLocalStorageEvent(const std::optional<StorageAreaImplIdentifier>&, const String& key, const String& oldValue, const String& newValue, const String& urlString);

    enum class SendMode : bool { Async, Sync };
    void sendConnectMessage(SendMode);
    void connectSync();
    void didConnect(StorageAreaIdentifier, HashMap<String, String>&&, uint64_t messageIdentifier);

    StorageAreaMapIdentifier m_identifier;
    uint64_t m_lastHandledMessageIdentifier { 0 };
    StorageNamespaceImpl& m_namespace;
    Ref<WebCore::SecurityOrigin> m_securityOrigin;
    std::unique_ptr<WebCore::StorageMap> m_map;
    std::optional<StorageAreaIdentifier> m_remoteAreaIdentifier;
    HashCountedSet<String> m_pendingValueChanges;
    uint64_t m_currentSeed { 0 };
    unsigned m_quotaInBytes;

Lines 25-30 messages -> StorageAreaMap NotRefCounted { a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.messages.in_sec1
- a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.messages.in -2 / +2 lines
25	DidRemoveItem(uint64_t storageMapSeed, String key)	25	DidRemoveItem(uint64_t storageMapSeed, String key)
26	DidClear(uint64_t storageMapSeed)	26	DidClear(uint64_t storageMapSeed)
27		27
28	DispatchStorageEvent(std::optional<WebKit::StorageAreaImplIdentifier> storageAreaImplID, String key, String oldValue, String newValue, String urlString)	28	DispatchStorageEvent(std::optional<WebKit::StorageAreaImplIdentifier> storageAreaImplID, String key, String oldValue, String newValue, String urlString, uint64_t messageIdentifier)
29	ClearCache()	29	ClearCache(uint64_t messageIdentifier)
30	}	30	}



/*
 * Copyright (C) 2022 Apple Inc. All rights reserved.
 *
 * 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.
 */

#pragma once

#include <wtf/ObjectIdentifier.h>

namespace WebKit {

enum StorageAreaMapIdentifierType { };
using StorageAreaMapIdentifier = ObjectIdentifier<StorageAreaMapIdentifierType>;

} // namespace WebKit


Return to Bug 235236

Lines 1057-1075 void Frame::dropChildren() a/Source/WebCore/page/Frame.cpp_sec1
- a/Source/WebCore/page/Frame.cpp -13 lines
1057	tree().removeChild(*child);	1057	tree().removeChild(*child);
1058	}	1058	}
1059		1059
1060	void Frame::didPrewarmLocalStorage()
1061	{
1062	ASSERT(isMainFrame());
1063	ASSERT(m_localStoragePrewarmingCount < maxlocalStoragePrewarmingCount);
1064	++m_localStoragePrewarmingCount;
1065	}
1066
1067	bool Frame::mayPrewarmLocalStorage() const
1068	{
1069	ASSERT(isMainFrame());
1070	return m_localStoragePrewarmingCount < maxlocalStoragePrewarmingCount;
1071	}
1072
1073	FloatSize Frame::screenSize() const	1060	FloatSize Frame::screenSize() const
1074	{	1061	{
1075	if (!m_overrideScreenSize.isEmpty())	1062	if (!m_overrideScreenSize.isEmpty())

Lines 291-299 public: a/Source/WebCore/page/Frame.h_sec1
- a/Source/WebCore/page/Frame.h -4 lines
291	void resumeActiveDOMObjectsAndAnimations();	291	void resumeActiveDOMObjectsAndAnimations();
292	bool activeDOMObjectsAndAnimationsSuspended() const { return m_activeDOMObjectsAndAnimationsSuspendedCount > 0; }	292	bool activeDOMObjectsAndAnimationsSuspended() const { return m_activeDOMObjectsAndAnimationsSuspendedCount > 0; }
293		293
294	void didPrewarmLocalStorage();
295	bool mayPrewarmLocalStorage() const;
296
297	enum class InvalidateContentEventRegionsReason { Layout, EventHandlerChange };	294	enum class InvalidateContentEventRegionsReason { Layout, EventHandlerChange };
298	void invalidateContentEventRegionsIfNeeded(InvalidateContentEventRegionsReason);	295	void invalidateContentEventRegionsIfNeeded(InvalidateContentEventRegionsReason);
299		296
Lines 361-367 private: a/Source/WebCore/page/Frame.h_sec2
361	unsigned m_navigationDisableCount { 0 };	358	unsigned m_navigationDisableCount { 0 };
362	unsigned m_selfOnlyRefCount { 0 };	359	unsigned m_selfOnlyRefCount { 0 };
363	bool m_hasHadUserInteraction { false };	360	bool m_hasHadUserInteraction { false };
364	unsigned m_localStoragePrewarmingCount { 0 };
365		361
366	FloatSize m_overrideScreenSize;	362	FloatSize m_overrideScreenSize;
367		363

Lines 165-171 void StorageArea::clear() a/Source/WebKit/NetworkProcess/WebStorage/StorageArea.cpp_sec1
- a/Source/WebKit/NetworkProcess/WebStorage/StorageArea.cpp -2 / +2 lines
165	}	165	}
166		166
167	for (auto& listenerUniqueID : m_eventListeners)	167	for (auto& listenerUniqueID : m_eventListeners)
168	IPC::Connection::send(listenerUniqueID, Messages::StorageAreaMap::ClearCache(), m_identifier.toUInt64());	168	IPC::Connection::send(listenerUniqueID, Messages::StorageAreaMap::ClearCache(0), m_identifier.toUInt64());
169	}	169	}
170		170
171	LocalStorageDatabase& StorageArea::ensureDatabase() const	171	LocalStorageDatabase& StorageArea::ensureDatabase() const
Lines 188-194 void StorageArea::dispatchEvents(IPC::Connection::UniqueID sourceConnection, Sto a/Source/WebKit/NetworkProcess/WebStorage/StorageArea.cpp_sec2
188	ASSERT(storageAreaImplID);	188	ASSERT(storageAreaImplID);
189	for (auto& listenerUniqueID : m_eventListeners) {	189	for (auto& listenerUniqueID : m_eventListeners) {
190	auto optionalStorageAreaImplID = listenerUniqueID == sourceConnection ? std::make_optional(storageAreaImplID) : std::nullopt;	190	auto optionalStorageAreaImplID = listenerUniqueID == sourceConnection ? std::make_optional(storageAreaImplID) : std::nullopt;
191	IPC::Connection::send(listenerUniqueID, Messages::StorageAreaMap::DispatchStorageEvent(optionalStorageAreaImplID, key, oldValue, newValue, urlString), m_identifier.toUInt64());	191	IPC::Connection::send(listenerUniqueID, Messages::StorageAreaMap::DispatchStorageEvent(optionalStorageAreaImplID, key, oldValue, newValue, urlString, 0), m_identifier.toUInt64());
192	}	192	}
193	}	193	}
194		194

Lines 625-648 void NetworkStorageManager::syncLocalStorage(CompletionHandler<void()>&& complet a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec1
- a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp -21 / +20 lines
625	});	625	});
626	}	626	}
627		627
628	void NetworkStorageManager::connectToLocalStorageArea(IPC::Connection& connection, StorageNamespaceIdentifier, WebCore::SecurityOriginData&& topOrigin, CompletionHandler<void(StorageAreaIdentifier)>&& completionHandler)	628	void NetworkStorageManager::connectToStorageArea(IPC::Connection& connection, WebCore::StorageType type, StorageAreaMapIdentifier sourceIdentifier, StorageNamespaceIdentifier namespaceIdentifier, const WebCore::ClientOrigin& origin, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&& completionHandler)
629	{	629	{
630	ASSERT(!RunLoop::isMain());	630	ASSERT(!RunLoop::isMain());
631		631
632	WebCore::ClientOrigin origin = { topOrigin, topOrigin };	632	auto connectionIdentifier = connection.uniqueID();
633	completionHandler(localOriginStorageManager(origin).localStorageManager(*m_storageAreaRegistry).connectToLocalStorageArea(connection.uniqueID(), origin, m_queue.copyRef()));	633	auto& originStorageManager = localOriginStorageManager(origin);
634	}	634	StorageAreaIdentifier resultIdentifier;
		635	switch (type) {
		636	case WebCore::StorageType::Local:
		637	resultIdentifier = originStorageManager.localStorageManager(*m_storageAreaRegistry).connectToLocalStorageArea(connectionIdentifier, sourceIdentifier, origin, m_queue.copyRef());
		638	break;
		639	case WebCore::StorageType::TransientLocal:
		640	resultIdentifier = originStorageManager.localStorageManager(*m_storageAreaRegistry).connectToTransientLocalStorageArea(connectionIdentifier, sourceIdentifier, origin);
		641	break;
		642	case WebCore::StorageType::Session:
		643	resultIdentifier = originStorageManager.sessionStorageManager(*m_storageAreaRegistry).connectToSessionStorageArea(connectionIdentifier, sourceIdentifier, origin, namespaceIdentifier);
		644	}
635		645
636	void NetworkStorageManager::connectToTransientLocalStorageArea(IPC::Connection& connection, StorageNamespaceIdentifier, WebCore::SecurityOriginData&& topOrigin, WebCore::SecurityOriginData&& openingOrigin, CompletionHandler<void(StorageAreaIdentifier)>&& completionHandler)	646	if (auto storageArea = m_storageAreaRegistry->getStorageArea(resultIdentifier))
637	{	647	return completionHandler(resultIdentifier, storageArea->allItems(), StorageAreaBase::nextMessageIdentifier());
638	WebCore::ClientOrigin origin = { topOrigin, openingOrigin };	648
639	completionHandler(localOriginStorageManager(origin).localStorageManager(*m_storageAreaRegistry).connectToTransientLocalStorageArea(connection.uniqueID(), origin));	649	return completionHandler(resultIdentifier, HashMap<String, String> { }, StorageAreaBase::nextMessageIdentifier());
640	}	650	}
641		651
642	void NetworkStorageManager::connectToSessionStorageArea(IPC::Connection& connection, StorageNamespaceIdentifier identifier, WebCore::SecurityOriginData&& topOrigin, CompletionHandler<void(StorageAreaIdentifier)>&& completionHandler)	652	void NetworkStorageManager::connectToStorageAreaSync(IPC::Connection& connection, WebCore::StorageType type, StorageAreaMapIdentifier sourceIdentifier, StorageNamespaceIdentifier namespaceIdentifier, const WebCore::ClientOrigin& origin, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&& completionHandler)
643	{	653	{
644	WebCore::ClientOrigin origin = { topOrigin, topOrigin };	654	connectToStorageArea(connection, type, sourceIdentifier, namespaceIdentifier, origin, WTFMove(completionHandler));
645	completionHandler(localOriginStorageManager(origin).sessionStorageManager(*m_storageAreaRegistry).connectToSessionStorageArea(connection.uniqueID(), origin, identifier));
646	}	655	}
647		656
648	void NetworkStorageManager::disconnectFromStorageArea(IPC::Connection& connection, StorageAreaIdentifier identifier)	657	void NetworkStorageManager::disconnectFromStorageArea(IPC::Connection& connection, StorageAreaIdentifier identifier)
Lines 669-684 void NetworkStorageManager::cloneSessionStorageNamespace(IPC::Connection& connec a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec2
669	}	678	}
670	}	679	}
671		680
672	void NetworkStorageManager::getValues(StorageAreaIdentifier identifier, CompletionHandler<void(const HashMap<String, String>&)>&& completionHandler)
673	{
674	ASSERT(!RunLoop::isMain());
675
676	if (auto storageArea = m_storageAreaRegistry->getStorageArea(identifier))
677	return completionHandler(storageArea->allItems());
678
679	return completionHandler({ });
680	}
681
682	void NetworkStorageManager::setItem(IPC::Connection& connection, StorageAreaIdentifier identifier, StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String&& key, String&& value, String&& urlString)	681	void NetworkStorageManager::setItem(IPC::Connection& connection, StorageAreaIdentifier identifier, StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String&& key, String&& value, String&& urlString)
683	{	682	{
684	ASSERT(!RunLoop::isMain());	683	ASSERT(!RunLoop::isMain());

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +17 lines
		1	2022-01-17 Sihui Liu <sihui_liu@apple.com>
		2
		3	Make LocalStorage prewarming async
		4	https://bugs.webkit.org/show_bug.cgi?id=235236
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* page/DOMWindow.cpp:
		9	(WebCore::DOMWindow::prewarmLocalStorageIfNecessary):
		10	* page/Frame.cpp:
		11	(WebCore::Frame::didPrewarmLocalStorage): Deleted.
		12	(WebCore::Frame::mayPrewarmLocalStorage const): Deleted.
		13	* page/Frame.h:
		14	* storage/StorageArea.h:
		15	(WebCore::StorageArea::prewarm):
		16	* storage/StorageType.h:
		17
1	2022-01-17 Carlos Garcia Campos <cgarcia@igalia.com>	18	2022-01-17 Carlos Garcia Campos <cgarcia@igalia.com>
2		19
3	[GTK][a11y] Stop using isolated tree for the ATSPI implementation	20	[GTK][a11y] Stop using isolated tree for the ATSPI implementation

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +88 lines
		1	2022-01-17 Sihui Liu <sihui_liu@apple.com>
		2
		3	Make LocalStorage prewarming async
		4	https://bugs.webkit.org/show_bug.cgi?id=235236
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	StorageAreaMap in web process needs to sync with a remote StorageArea in network process before it performs any
		9	Web Storage operation. To connect to remote StorageArea, StorageAreaMap currently sends out two sync messages:
		10	1. ConnectTo*StorageArea: for getting the remote StorageAreaIdentifier
		11	2. getValues: for getting the content of StorageArea
		12	We can merge these two messages into one message: ConnectToStorageAreaSync, and return both remote
		13	StorageAreaIdentifier and content in its reply. This way, web process will not be blocked twice.
		14
		15	To reduce the wait time for connecting to a local StorageArea, we would prewarm LocalStorage by creating its
		16	StorageAreaMap ahead and making it connected (r247555), but we don't actually need StorageAreaMap to be ready
		17	for operation at this time. Therefore, a new async message ConnectToStorageArea is added to be used for
		18	prewarming.
		19
		20	If LocalStorage is used immediately after prewarming, a StorageAreaMap may send ConnectToStorageAreaSync before
		21	receiving the reply of ConnectToStorageArea. In this case, StorageAreaMap would handle ConnectToStorageAreaSync
		22	reply before ConnectToStorageArea reply (due to the priority of sync message), and also before other async
		23	messages (DispatchStorageEvent / ClearCache) that are sent from network process earlier before the sync reply.
		24	To solve this, we use a message identifier to indicate the order of messages sent from network process, so
		25	StorageAreaMap can ignore previous messages when it is already synced with a more recent version of StorageArea.
		26
		27	* NetworkProcess/WebStorage/StorageArea.cpp:
		28	(WebKit::StorageArea::clear):
		29	(WebKit::StorageArea::dispatchEvents const):
		30	* NetworkProcess/storage/LocalStorageManager.cpp:
		31	(WebKit::LocalStorageManager::connectToLocalStorageArea):
		32	(WebKit::LocalStorageManager::connectToTransientLocalStorageArea):
		33	* NetworkProcess/storage/LocalStorageManager.h:
		34	* NetworkProcess/storage/NetworkStorageManager.cpp:
		35	(WebKit::NetworkStorageManager::connectToStorageArea):
		36	(WebKit::NetworkStorageManager::connectToStorageAreaSync):
		37	(WebKit::NetworkStorageManager::connectToLocalStorageArea): Deleted.
		38	(WebKit::NetworkStorageManager::connectToTransientLocalStorageArea): Deleted.
		39	(WebKit::NetworkStorageManager::connectToSessionStorageArea): Deleted.
		40	(WebKit::NetworkStorageManager::getValues): Deleted.
		41	* NetworkProcess/storage/NetworkStorageManager.h:
		42	* NetworkProcess/storage/NetworkStorageManager.messages.in:
		43	* NetworkProcess/storage/SessionStorageManager.cpp:
		44	(WebKit::SessionStorageManager::connectToSessionStorageArea):
		45	* NetworkProcess/storage/SessionStorageManager.h:
		46	* NetworkProcess/storage/StorageAreaBase.cpp:
		47	(WebKit::StorageAreaBase::nextMessageIdentifier):
		48	(WebKit::StorageAreaBase::StorageAreaBase):
		49	(WebKit::StorageAreaBase::addListener):
		50	(WebKit::StorageAreaBase::notifyListenersAboutClear):
		51	(WebKit::StorageAreaBase::dispatchEvents const):
		52	* NetworkProcess/storage/StorageAreaBase.h:
		53	* Scripts/webkit/messages.py:
		54	(types_that_cannot_be_forward_declared):
		55	(headers_for_type):
		56	* WebKit.xcodeproj/project.pbxproj:
		57	* WebProcess/Network/NetworkProcessConnection.cpp:
		58	(WebKit::NetworkProcessConnection::didReceiveMessage):
		59	* WebProcess/WebProcess.cpp:
		60	(WebKit::WebProcess::networkProcessConnectionClosed):
		61	(WebKit::WebProcess::registerStorageAreaMap):
		62	(WebKit::WebProcess::unregisterStorageAreaMap):
		63	(WebKit::WebProcess::storageAreaMap const):
		64	* WebProcess/WebProcess.h:
65	* WebProcess/WebStorage/StorageAreaImpl.cpp:
66	(WebKit::StorageAreaImpl::prewarm):
67	(WebKit::StorageAreaImpl::incrementAccessCount): Deleted.
68	(WebKit::StorageAreaImpl::decrementAccessCount): Deleted.
69	(WebKit::StorageAreaImpl::closeDatabaseIfIdle): Deleted.
70	* WebProcess/WebStorage/StorageAreaImpl.h:
71	* WebProcess/WebStorage/StorageAreaMap.cpp:
72	(WebKit::StorageAreaMap::StorageAreaMap):
73	(WebKit::StorageAreaMap::~StorageAreaMap):
74	(WebKit::StorageAreaMap::setItem):
75	(WebKit::StorageAreaMap::removeItem):
76	(WebKit::StorageAreaMap::clear):
77	(WebKit::StorageAreaMap::ensureMap):
78	(WebKit::StorageAreaMap::dispatchStorageEvent):
79	(WebKit::StorageAreaMap::clearCache):
80	(WebKit::StorageAreaMap::sendConnectMessage):
81	(WebKit::StorageAreaMap::connectSync):
82	(WebKit::StorageAreaMap::connect):
83	(WebKit::StorageAreaMap::didConnect):
84	(WebKit::StorageAreaMap::disconnect):
85	* WebProcess/WebStorage/StorageAreaMap.h:
86	* WebProcess/WebStorage/StorageAreaMap.messages.in:
87	* WebProcess/WebStorage/StorageAreaMapIdentifier.h: Added.
88
1	2022-01-17 Kimmo Kinnunen <kkinnunen@apple.com>	89	2022-01-17 Kimmo Kinnunen <kkinnunen@apple.com>
2		90
3	Frequent GPU process jetsams due to RemoteRenderingBackendProxy not claiming ownership of SharedMemory buffers	91	Frequent GPU process jetsams due to RemoteRenderingBackendProxy not claiming ownership of SharedMemory buffers

Lines 413-421 void DOMWindow::prewarmLocalStorageIfNecessary() a/Source/WebCore/page/DOMWindow.cpp_sec1
- a/Source/WebCore/page/DOMWindow.cpp -4 / +1 lines
413	if (!page \|\| page->usesEphemeralSession())	413	if (!page \|\| page->usesEphemeralSession())
414	return;	414	return;
415		415
416	if (!page->mainFrame().mayPrewarmLocalStorage())
417	return;
418
419	// This eagerly constructs the StorageArea, which will load items from disk.	416	// This eagerly constructs the StorageArea, which will load items from disk.
420	auto localStorageResult = this->localStorage();	417	auto localStorageResult = this->localStorage();
421	if (localStorageResult.hasException())	418	if (localStorageResult.hasException())
Lines 425-431 void DOMWindow::prewarmLocalStorageIfNecessary() a/Source/WebCore/page/DOMWindow.cpp_sec2
425	if (!localStorage)	422	if (!localStorage)
426	return;	423	return;
427		424
428	page->mainFrame().didPrewarmLocalStorage();	425	localStorage->area().prewarm();
429	}	426	}
430		427
431	DOMWindow::~DOMWindow()	428	DOMWindow::~DOMWindow()

Lines 44-46 inline bool isPersistentLocalStorage(StorageType storageType) a/Source/WebCore/storage/StorageType.h_sec1
- a/Source/WebCore/storage/StorageType.h +13 lines
44	}	44	}
45		45
46	} // namespace WebCore	46	} // namespace WebCore
		47
		48	namespace WTF {
		49
		50	template<> struct EnumTraits<WebCore::StorageType> {
		51	using values = EnumValues<
		52	WebCore::StorageType,
		53	WebCore::StorageType::Session,
		54	WebCore::StorageType::Local,
		55	WebCore::StorageType::TransientLocal
		56	>;
		57	};
		58
		59	} // namespace WTF

Lines 165-171 void LocalStorageManager::connectionClosedForTransientStorageArea(IPC::Connectio a/Source/WebKit/NetworkProcess/storage/LocalStorageManager.cpp_sec1
- a/Source/WebKit/NetworkProcess/storage/LocalStorageManager.cpp -4 / +4 lines
165	m_transientStorageArea = nullptr;	165	m_transientStorageArea = nullptr;
166	}	166	}
167		167
168	StorageAreaIdentifier LocalStorageManager::connectToLocalStorageArea(IPC::Connection::UniqueID connection, const WebCore::ClientOrigin& origin, Ref<WorkQueue>&& workQueue)	168	StorageAreaIdentifier LocalStorageManager::connectToLocalStorageArea(IPC::Connection::UniqueID connection, StorageAreaMapIdentifier sourceIdentifier, const WebCore::ClientOrigin& origin, Ref<WorkQueue>&& workQueue)
169	{	169	{
170	if (!m_localStorageArea) {	170	if (!m_localStorageArea) {
171	if (!m_path.isEmpty())	171	if (!m_path.isEmpty())
Lines 177-187 StorageAreaIdentifier LocalStorageManager::connectToLocalStorageArea(IPC::Connec a/Source/WebKit/NetworkProcess/storage/LocalStorageManager.cpp_sec2
177	}	177	}
178		178
179	ASSERT(m_path.isEmpty() \|\| m_localStorageArea->type() == StorageAreaBase::Type::SQLite);	179	ASSERT(m_path.isEmpty() \|\| m_localStorageArea->type() == StorageAreaBase::Type::SQLite);
180	m_localStorageArea->addListener(connection);	180	m_localStorageArea->addListener(connection, sourceIdentifier);
181	return m_localStorageArea->identifier();	181	return m_localStorageArea->identifier();
182	}	182	}
183		183
184	StorageAreaIdentifier LocalStorageManager::connectToTransientLocalStorageArea(IPC::Connection::UniqueID connection, const WebCore::ClientOrigin& origin)	184	StorageAreaIdentifier LocalStorageManager::connectToTransientLocalStorageArea(IPC::Connection::UniqueID connection, StorageAreaMapIdentifier sourceIdentifier, const WebCore::ClientOrigin& origin)
185	{	185	{
186	if (!m_transientStorageArea) {	186	if (!m_transientStorageArea) {
187	m_transientStorageArea = makeUnique<MemoryStorageArea>(origin, StorageAreaBase::StorageType::Local);	187	m_transientStorageArea = makeUnique<MemoryStorageArea>(origin, StorageAreaBase::StorageType::Local);
Lines 189-195 StorageAreaIdentifier LocalStorageManager::connectToTransientLocalStorageArea(IP a/Source/WebKit/NetworkProcess/storage/LocalStorageManager.cpp_sec3
189	}	189	}
190		190
191	ASSERT(m_transientStorageArea->type() == StorageAreaBase::Type::Memory);	191	ASSERT(m_transientStorageArea->type() == StorageAreaBase::Type::Memory);
192	m_transientStorageArea->addListener(connection);	192	m_transientStorageArea->addListener(connection, sourceIdentifier);
193	return m_transientStorageArea->identifier();	193	return m_transientStorageArea->identifier();
194	}	194	}
195		195

Lines 27-32 a/Source/WebKit/NetworkProcess/storage/LocalStorageManager.h_sec1
- a/Source/WebKit/NetworkProcess/storage/LocalStorageManager.h -2 / +3 lines
27		27
28	#include "Connection.h"	28	#include "Connection.h"
29	#include "StorageAreaIdentifier.h"	29	#include "StorageAreaIdentifier.h"
		30	#include "StorageAreaMapIdentifier.h"
30	#include <wtf/WorkQueue.h>	31	#include <wtf/WorkQueue.h>
31		32
32	namespace WebCore {	33	namespace WebCore {
Lines 56-63 public: a/Source/WebKit/NetworkProcess/storage/LocalStorageManager.h_sec2
56	void syncLocalStorage();	57	void syncLocalStorage();
57	void connectionClosed(IPC::Connection::UniqueID);	58	void connectionClosed(IPC::Connection::UniqueID);
58		59
59	StorageAreaIdentifier connectToLocalStorageArea(IPC::Connection::UniqueID, const WebCore::ClientOrigin&, Ref<WorkQueue>&&);	60	StorageAreaIdentifier connectToLocalStorageArea(IPC::Connection::UniqueID, StorageAreaMapIdentifier, const WebCore::ClientOrigin&, Ref<WorkQueue>&&);
60	StorageAreaIdentifier connectToTransientLocalStorageArea(IPC::Connection::UniqueID, const WebCore::ClientOrigin&);	61	StorageAreaIdentifier connectToTransientLocalStorageArea(IPC::Connection::UniqueID, StorageAreaMapIdentifier, const WebCore::ClientOrigin&);
61	void disconnectFromStorageArea(IPC::Connection::UniqueID, StorageAreaIdentifier);	62	void disconnectFromStorageArea(IPC::Connection::UniqueID, StorageAreaIdentifier);
62		63
63	private:	64	private:

Lines 30-35 a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec1
- a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h -4 / +4 lines
30	#include "OriginStorageManager.h"	30	#include "OriginStorageManager.h"
31	#include "StorageAreaIdentifier.h"	31	#include "StorageAreaIdentifier.h"
32	#include "StorageAreaImplIdentifier.h"	32	#include "StorageAreaImplIdentifier.h"
		33	#include "StorageAreaMapIdentifier.h"
33	#include "StorageNamespaceIdentifier.h"	34	#include "StorageNamespaceIdentifier.h"
34	#include "WebsiteData.h"	35	#include "WebsiteData.h"
35	#include <WebCore/ClientOrigin.h>	36	#include <WebCore/ClientOrigin.h>
Lines 44-49 class SharedFileHandle; a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec2
44		45
45	namespace WebCore {	46	namespace WebCore {
46	struct ClientOrigin;	47	struct ClientOrigin;
		48	enum class StorageType : uint8_t;
47	}	49	}
48		50
49	namespace WebKit {	51	namespace WebKit {
Lines 108-119 private: a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec3
108	void getHandle(IPC::Connection&, WebCore::FileSystemHandleIdentifier, String&& name, CompletionHandler<void(Expected<std::pair<WebCore::FileSystemHandleIdentifier, bool>, FileSystemStorageError>)>&&);	110	void getHandle(IPC::Connection&, WebCore::FileSystemHandleIdentifier, String&& name, CompletionHandler<void(Expected<std::pair<WebCore::FileSystemHandleIdentifier, bool>, FileSystemStorageError>)>&&);
109		111
110	// Message handlers for WebStorage.	112	// Message handlers for WebStorage.
111	void connectToLocalStorageArea(IPC::Connection&, StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, CompletionHandler<void(StorageAreaIdentifier)>&&);	113	void connectToStorageArea(IPC::Connection&, WebCore::StorageType, StorageAreaMapIdentifier, StorageNamespaceIdentifier, const WebCore::ClientOrigin&, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&&);
112	void connectToTransientLocalStorageArea(IPC::Connection&, StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, WebCore::SecurityOriginData&&, CompletionHandler<void(StorageAreaIdentifier)>&&);	114	void connectToStorageAreaSync(IPC::Connection&, WebCore::StorageType, StorageAreaMapIdentifier, StorageNamespaceIdentifier, const WebCore::ClientOrigin&, CompletionHandler<void(StorageAreaIdentifier, HashMap<String, String>, uint64_t)>&&);
113	void connectToSessionStorageArea(IPC::Connection&, StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, CompletionHandler<void(StorageAreaIdentifier)>&&);
114	void disconnectFromStorageArea(IPC::Connection&, StorageAreaIdentifier);	115	void disconnectFromStorageArea(IPC::Connection&, StorageAreaIdentifier);
115	void cloneSessionStorageNamespace(IPC::Connection&, StorageNamespaceIdentifier, StorageNamespaceIdentifier);	116	void cloneSessionStorageNamespace(IPC::Connection&, StorageNamespaceIdentifier, StorageNamespaceIdentifier);
116	void getValues(StorageAreaIdentifier, CompletionHandler<void(const HashMap<String, String>&)>&&);
117	void setItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& key, String&& value, String&& urlString);	117	void setItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& key, String&& value, String&& urlString);
118	void removeItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& key, String&& urlString);	118	void removeItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& key, String&& urlString);
119	void clear(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& urlString);	119	void clear(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, uint64_t seed, String&& urlString);

Lines 40-51 a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.messages.in_sec1
- a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.messages.in -4 / +2 lines
40	GetHandleNames(WebCore::FileSystemHandleIdentifier identifier) -> (Expected<Vector<String>, WebKit::FileSystemStorageError> result) Async	40	GetHandleNames(WebCore::FileSystemHandleIdentifier identifier) -> (Expected<Vector<String>, WebKit::FileSystemStorageError> result) Async
41	GetHandle(WebCore::FileSystemHandleIdentifier identifier, String name) -> (Expected<std::pair<WebCore::FileSystemHandleIdentifier, bool>, WebKit::FileSystemStorageError> result) Async WantsConnection	41	GetHandle(WebCore::FileSystemHandleIdentifier identifier, String name) -> (Expected<std::pair<WebCore::FileSystemHandleIdentifier, bool>, WebKit::FileSystemStorageError> result) Async WantsConnection
42		42
43	ConnectToLocalStorageArea(WebKit::StorageNamespaceIdentifier storageNamespaceID, struct WebCore::SecurityOriginData securityOriginData) -> (WebKit::StorageAreaIdentifier identifier) Synchronous WantsConnection	43	ConnectToStorageArea(WebCore::StorageType type, WebKit::StorageAreaMapIdentifier sourceIdentifier, WebKit::StorageNamespaceIdentifier namespaceIdentifier, struct WebCore::ClientOrigin origin) -> (WebKit::StorageAreaIdentifier identifier, HashMap<String, String> items, uint64_t messageIdentifier) Async WantsConnection
44	ConnectToTransientLocalStorageArea(WebKit::StorageNamespaceIdentifier storageNamespaceID, struct WebCore::SecurityOriginData topLevelSecurityOriginData, struct WebCore::SecurityOriginData securityOriginData) -> (WebKit::StorageAreaIdentifier identifier) Synchronous WantsConnection	44	ConnectToStorageAreaSync(WebCore::StorageType type, WebKit::StorageAreaMapIdentifier sourceIdentifier, WebKit::StorageNamespaceIdentifier namespaceIdentifier, struct WebCore::ClientOrigin origin) -> (WebKit::StorageAreaIdentifier identifier, HashMap<String, String> items, uint64_t messageIdentifier) Synchronous WantsConnection
45	ConnectToSessionStorageArea(WebKit::StorageNamespaceIdentifier storageNamespaceID, struct WebCore::SecurityOriginData securityOriginData) -> (WebKit::StorageAreaIdentifier identifier) Synchronous WantsConnection
46	DisconnectFromStorageArea(WebKit::StorageAreaIdentifier identifier) WantsConnection	45	DisconnectFromStorageArea(WebKit::StorageAreaIdentifier identifier) WantsConnection
47	CloneSessionStorageNamespace(WebKit::StorageNamespaceIdentifier fromStorageNamespaceID, WebKit::StorageNamespaceIdentifier toStorageNamespaceID) WantsConnection	46	CloneSessionStorageNamespace(WebKit::StorageNamespaceIdentifier fromStorageNamespaceID, WebKit::StorageNamespaceIdentifier toStorageNamespaceID) WantsConnection
48	GetValues(WebKit::StorageAreaIdentifier identifier) -> (HashMap<String, String> values) Synchronous
49	SetItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String key, String value, String urlString) WantsConnection	47	SetItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String key, String value, String urlString) WantsConnection
50	RemoveItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String key, String urlString) WantsConnection	48	RemoveItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String key, String urlString) WantsConnection
51	Clear(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String urlString) WantsConnection	49	Clear(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, uint64_t storageMapSeed, String urlString) WantsConnection

Lines 72-78 StorageAreaIdentifier SessionStorageManager::addStorageArea(std::unique_ptr<Memo a/Source/WebKit/NetworkProcess/storage/SessionStorageManager.cpp_sec1
- a/Source/WebKit/NetworkProcess/storage/SessionStorageManager.cpp -2 / +3 lines
72	return identifier;	72	return identifier;
73	}	73	}
74		74
75	StorageAreaIdentifier SessionStorageManager::connectToSessionStorageArea(IPC::Connection::UniqueID connection, const WebCore::ClientOrigin& origin, StorageNamespaceIdentifier namespaceIdentifier)	75	StorageAreaIdentifier SessionStorageManager::connectToSessionStorageArea(IPC::Connection::UniqueID connection, StorageAreaMapIdentifier sourceIdentifier, const WebCore::ClientOrigin& origin, StorageNamespaceIdentifier namespaceIdentifier)
76	{	76	{
77	auto identifier = m_storageAreasByNamespace.get(namespaceIdentifier);	77	auto identifier = m_storageAreasByNamespace.get(namespaceIdentifier);
78	if (!identifier.isValid()) {	78	if (!identifier.isValid()) {
Lines 84-90 StorageAreaIdentifier SessionStorageManager::connectToSessionStorageArea(IPC::Co a/Source/WebKit/NetworkProcess/storage/SessionStorageManager.cpp_sec2
84	if (!storageArea)	84	if (!storageArea)
85	return StorageAreaIdentifier { };	85	return StorageAreaIdentifier { };
86		86
87	storageArea->addListener(connection);	87	storageArea->addListener(connection, sourceIdentifier);
		88
88	return identifier;	89	return identifier;
89	}	90	}
90		91

Lines 305-310 def types_that_cannot_be_forward_declared(): a/Source/WebKit/Scripts/webkit/messages.py_sec1
- a/Source/WebKit/Scripts/webkit/messages.py +2 lines
305	'WebCore::SleepDisablerIdentifier',	305	'WebCore::SleepDisablerIdentifier',
306	'WebCore::SourceBufferAppendMode',	306	'WebCore::SourceBufferAppendMode',
307	'WebCore::SpeechRecognitionConnectionClientIdentifier',	307	'WebCore::SpeechRecognitionConnectionClientIdentifier',
		308	'WebCore::StorageType',
308	'WebCore::UserMediaRequestIdentifier',	309	'WebCore::UserMediaRequestIdentifier',
309	'WebCore::WebLockIdentifier',	310	'WebCore::WebLockIdentifier',
310	'WebCore::WebSocketIdentifier',	311	'WebCore::WebSocketIdentifier',
Lines 347-352 def types_that_cannot_be_forward_declared(): a/Source/WebKit/Scripts/webkit/messages.py_sec2
347	'WebKit::SampleBufferDisplayLayerIdentifier',	348	'WebKit::SampleBufferDisplayLayerIdentifier',
348	'WebKit::StorageAreaIdentifier',	349	'WebKit::StorageAreaIdentifier',
349	'WebKit::StorageAreaImplIdentifier',	350	'WebKit::StorageAreaImplIdentifier',
		351	'WebKit::StorageAreaMapIdentifier',
350	'WebKit::StorageNamespaceIdentifier',	352	'WebKit::StorageNamespaceIdentifier',
351	'WebKit::TapIdentifier',	353	'WebKit::TapIdentifier',
352	'WebKit::TextCheckerRequestID',	354	'WebKit::TextCheckerRequestID',

Lines 1189-1196 void WebProcess::networkProcessConnectionClosed(NetworkProcessConnection* connec a/Source/WebKit/WebProcess/WebProcess.cpp_sec1
- a/Source/WebKit/WebProcess/WebProcess.cpp -10 / +10 lines
1189	ASSERT(m_networkProcessConnection);	1189	ASSERT(m_networkProcessConnection);
1190	ASSERT_UNUSED(connection, m_networkProcessConnection == connection);	1190	ASSERT_UNUSED(connection, m_networkProcessConnection == connection);
1191		1191
1192	for (auto* storageAreaMap : copyToVector(m_storageAreaMaps.values()))	1192	for (auto key : copyToVector(m_storageAreaMaps.keys()))
1193	storageAreaMap->disconnect();	1193	m_storageAreaMaps.get(key)->disconnect();
1194		1194
1195	for (auto& page : m_pageMap.values()) {	1195	for (auto& page : m_pageMap.values()) {
1196	auto idbConnection = page->corePage()->optionalIDBConnection();	1196	auto idbConnection = page->corePage()->optionalIDBConnection();
Lines 1697-1716 void WebProcess::nonVisibleProcessMemoryCleanupTimerFired() a/Source/WebKit/WebProcess/WebProcess.cpp_sec2
1697		1697
1698	void WebProcess::registerStorageAreaMap(StorageAreaMap& storageAreaMap)	1698	void WebProcess::registerStorageAreaMap(StorageAreaMap& storageAreaMap)
1699	{	1699	{
1700	ASSERT(storageAreaMap.identifier());	1700	auto identifier = storageAreaMap.identifier();
1701	ASSERT(!m_storageAreaMaps.contains(*storageAreaMap.identifier()));	1701	ASSERT(!m_storageAreaMaps.contains(identifier));
1702	m_storageAreaMaps.set(*storageAreaMap.identifier(), &storageAreaMap);	1702	m_storageAreaMaps.add(identifier, storageAreaMap);
1703	}	1703	}
1704		1704
1705	void WebProcess::unregisterStorageAreaMap(StorageAreaMap& storageAreaMap)	1705	void WebProcess::unregisterStorageAreaMap(StorageAreaMap& storageAreaMap)
1706	{	1706	{
1707	ASSERT(storageAreaMap.identifier());	1707	auto identifier = storageAreaMap.identifier();
1708	ASSERT(m_storageAreaMaps.contains(*storageAreaMap.identifier()));	1708	ASSERT(m_storageAreaMaps.contains(identifier));
1709	ASSERT(m_storageAreaMaps.get(*storageAreaMap.identifier()) == &storageAreaMap);	1709	ASSERT(m_storageAreaMaps.get(identifier).get() == &storageAreaMap);
1710	m_storageAreaMaps.remove(*storageAreaMap.identifier());	1710	m_storageAreaMaps.remove(identifier);
1711	}	1711	}
1712		1712
1713	StorageAreaMap* WebProcess::storageAreaMap(StorageAreaIdentifier identifier) const	1713	WeakPtr<StorageAreaMap> WebProcess::storageAreaMap(StorageAreaMapIdentifier identifier) const
1714	{	1714	{
1715	return m_storageAreaMaps.get(identifier);	1715	return m_storageAreaMaps.get(identifier);
1716	}	1716	}

Lines 1457-1462 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec1
- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj +4 lines
1457	93AB9B4E257567E20098B10E /* SpeechRecognitionRemoteRealtimeMediaSource.h in Headers / = {isa = PBXBuildFile; fileRef = 93AB9B422574928C0098B10E / SpeechRecognitionRemoteRealtimeMediaSource.h */; };	1457	93AB9B4E257567E20098B10E /* SpeechRecognitionRemoteRealtimeMediaSource.h in Headers / = {isa = PBXBuildFile; fileRef = 93AB9B422574928C0098B10E / SpeechRecognitionRemoteRealtimeMediaSource.h */; };
1458	93AB9B552575A2760098B10E /* SpeechRecognitionRealtimeMediaSourceManagerMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 93AB9B4F257589110098B10E / SpeechRecognitionRealtimeMediaSourceManagerMessageReceiver.cpp */; };	1458	93AB9B552575A2760098B10E /* SpeechRecognitionRealtimeMediaSourceManagerMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 93AB9B4F257589110098B10E / SpeechRecognitionRealtimeMediaSourceManagerMessageReceiver.cpp */; };
1459	93AB9B562575A28B0098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 93AB9B51257589110098B10E / SpeechRecognitionRemoteRealtimeMediaSourceManagerMessageReceiver.cpp */; };	1459	93AB9B562575A28B0098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 93AB9B51257589110098B10E / SpeechRecognitionRemoteRealtimeMediaSourceManagerMessageReceiver.cpp */; };
		1460	93AEC161278F8CD30066666F /* StorageAreaMapIdentifier.h in Headers / = {isa = PBXBuildFile; fileRef = 93AEC160278F8CD20066666F / StorageAreaMapIdentifier.h */; };
1460	93B0A67526D5ADCF00AA21E4 /* WebPermissionController.h in Headers / = {isa = PBXBuildFile; fileRef = 93B0A67426D5A72E00AA21E4 / WebPermissionController.h */; };	1461	93B0A67526D5ADCF00AA21E4 /* WebPermissionController.h in Headers / = {isa = PBXBuildFile; fileRef = 93B0A67426D5A72E00AA21E4 / WebPermissionController.h */; };
1461	93B2614D227D149E00B97A76 /* StorageManager.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26149227D147200B97A76 / StorageManager.h */; };	1462	93B2614D227D149E00B97A76 /* StorageManager.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26149227D147200B97A76 / StorageManager.h */; };
1462	93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26145227D147000B97A76 / LocalStorageDatabase.h */; };	1463	93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26145227D147000B97A76 / LocalStorageDatabase.h */; };
Lines 5305-5310 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec2
5305	93AB9B52257589120098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessagesReplies.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRemoteRealtimeMediaSourceManagerMessagesReplies.h; sourceTree = "<group>"; };	5306	93AB9B52257589120098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessagesReplies.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRemoteRealtimeMediaSourceManagerMessagesReplies.h; sourceTree = "<group>"; };
5306	93AB9B53257589120098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRemoteRealtimeMediaSourceManagerMessages.h; sourceTree = "<group>"; };	5307	93AB9B53257589120098B10E /* SpeechRecognitionRemoteRealtimeMediaSourceManagerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRemoteRealtimeMediaSourceManagerMessages.h; sourceTree = "<group>"; };
5307	93AB9B54257589120098B10E /* SpeechRecognitionRealtimeMediaSourceManagerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRealtimeMediaSourceManagerMessages.h; sourceTree = "<group>"; };	5308	93AB9B54257589120098B10E /* SpeechRecognitionRealtimeMediaSourceManagerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpeechRecognitionRealtimeMediaSourceManagerMessages.h; sourceTree = "<group>"; };
		5309	93AEC160278F8CD20066666F /* StorageAreaMapIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageAreaMapIdentifier.h; sourceTree = "<group>"; };
5308	93B0A67326D5A72E00AA21E4 /* WebPermissionController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPermissionController.cpp; sourceTree = "<group>"; };	5310	93B0A67326D5A72E00AA21E4 /* WebPermissionController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPermissionController.cpp; sourceTree = "<group>"; };
5309	93B0A67426D5A72E00AA21E4 /* WebPermissionController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPermissionController.h; sourceTree = "<group>"; };	5311	93B0A67426D5A72E00AA21E4 /* WebPermissionController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPermissionController.h; sourceTree = "<group>"; };
5310	93B26145227D147000B97A76 /* LocalStorageDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalStorageDatabase.h; sourceTree = "<group>"; };	5312	93B26145227D147000B97A76 /* LocalStorageDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalStorageDatabase.h; sourceTree = "<group>"; };
Lines 7061-7066 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec3
7061	1ACECD2217162DB1001FC9EF /* StorageAreaMap.cpp */,	7063	1ACECD2217162DB1001FC9EF /* StorageAreaMap.cpp */,
7062	1ACECD2317162DB1001FC9EF /* StorageAreaMap.h */,	7064	1ACECD2317162DB1001FC9EF /* StorageAreaMap.h */,
7063	1A334DEA16DE8B68006A8E38 /* StorageAreaMap.messages.in */,	7065	1A334DEA16DE8B68006A8E38 /* StorageAreaMap.messages.in */,
		7066	93AEC160278F8CD20066666F /* StorageAreaMapIdentifier.h */,
7064	465F4E05230B2E7C003CEDB7 /* StorageNamespaceIdentifier.h */,	7067	465F4E05230B2E7C003CEDB7 /* StorageNamespaceIdentifier.h */,
7065	1A17635416B1D5D000D88FD6 /* StorageNamespaceImpl.cpp */,	7068	1A17635416B1D5D000D88FD6 /* StorageNamespaceImpl.cpp */,
7066	1A17635516B1D5D000D88FD6 /* StorageNamespaceImpl.h */,	7069	1A17635516B1D5D000D88FD6 /* StorageNamespaceImpl.h */,
Lines 13263-13268 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec4
13263	93E799DC276121080074008A /* StorageAreaBase.h in Headers */,	13266	93E799DC276121080074008A /* StorageAreaBase.h in Headers */,
13264	1AD3306F16B1D991004F60E7 /* StorageAreaImpl.h in Headers */,	13267	1AD3306F16B1D991004F60E7 /* StorageAreaImpl.h in Headers */,
13265	1ACECD2517162DB1001FC9EF /* StorageAreaMap.h in Headers */,	13268	1ACECD2517162DB1001FC9EF /* StorageAreaMap.h in Headers */,
		13269	93AEC161278F8CD30066666F /* StorageAreaMapIdentifier.h in Headers */,
13266	1A334DEE16DE8F88006A8E38 /* StorageAreaMapMessages.h in Headers */,	13270	1A334DEE16DE8F88006A8E38 /* StorageAreaMapMessages.h in Headers */,
13267	93E799C7276027460074008A /* StorageAreaRegistry.h in Headers */,	13271	93E799C7276027460074008A /* StorageAreaRegistry.h in Headers */,
13268	93B2614D227D149E00B97A76 /* StorageManager.h in Headers */,	13272	93B2614D227D149E00B97A76 /* StorageManager.h in Headers */,

Lines 30-36 a/Source/WebKit/WebProcess/WebProcess.h_sec1
- a/Source/WebKit/WebProcess/WebProcess.h -3 / +3 lines
30	#include "CacheModel.h"	30	#include "CacheModel.h"
31	#include "IdentifierTypes.h"	31	#include "IdentifierTypes.h"
32	#include "SandboxExtension.h"	32	#include "SandboxExtension.h"
33	#include "StorageAreaIdentifier.h"	33	#include "StorageAreaMapIdentifier.h"
34	#include "TextCheckerState.h"	34	#include "TextCheckerState.h"
35	#include "UserContentControllerIdentifier.h"	35	#include "UserContentControllerIdentifier.h"
36	#include "ViewUpdateDispatcher.h"	36	#include "ViewUpdateDispatcher.h"
Lines 284-290 public: a/Source/WebKit/WebProcess/WebProcess.h_sec2
284		284
285	void registerStorageAreaMap(StorageAreaMap&);	285	void registerStorageAreaMap(StorageAreaMap&);
286	void unregisterStorageAreaMap(StorageAreaMap&);	286	void unregisterStorageAreaMap(StorageAreaMap&);
287	StorageAreaMap* storageAreaMap(StorageAreaIdentifier) const;	287	WeakPtr<StorageAreaMap> storageAreaMap(StorageAreaMapIdentifier) const;
288		288
289	#if PLATFORM(COCOA)	289	#if PLATFORM(COCOA)
290	RetainPtr<CFDataRef> sourceApplicationAuditData() const;	290	RetainPtr<CFDataRef> sourceApplicationAuditData() const;
Lines 742-748 private: a/Source/WebKit/WebProcess/WebProcess.h_sec3
742	HashCountedSet<WebCore::ServiceWorkerRegistrationIdentifier> m_swRegistrationCounts;	742	HashCountedSet<WebCore::ServiceWorkerRegistrationIdentifier> m_swRegistrationCounts;
743	#endif	743	#endif
744		744
745	HashMap<StorageAreaIdentifier, StorageAreaMap*> m_storageAreaMaps;	745	HashMap<StorageAreaMapIdentifier, WeakPtr<StorageAreaMap>> m_storageAreaMaps;
746		746
747	// Prewarmed WebProcesses do not have an associated sessionID yet, which is why this is an optional.	747	// Prewarmed WebProcesses do not have an associated sessionID yet, which is why this is an optional.
748	// By the time the WebProcess gets a WebPage, it is guaranteed to have a sessionID.	748	// By the time the WebProcess gets a WebPage, it is guaranteed to have a sessionID.

Lines 112-131 size_t StorageAreaImpl::memoryBytesUsedByCache() a/Source/WebKit/WebProcess/WebStorage/StorageAreaImpl.cpp_sec1
- a/Source/WebKit/WebProcess/WebStorage/StorageAreaImpl.cpp -13 / +3 lines
112	return 0;	112	return 0;
113	}	113	}
114		114
115	void StorageAreaImpl::incrementAccessCount()	115	void StorageAreaImpl::prewarm()
116	{	116	{
117	// Storage access is handled in the network process, so there's nothing to do here.	117	if (m_storageAreaMap)
118	}	118	m_storageAreaMap->connect();
119
120	void StorageAreaImpl::decrementAccessCount()
121	{
122	// Storage access is handled in the network process, so there's nothing to do here.
123	}
124
125	void StorageAreaImpl::closeDatabaseIfIdle()
126	{
127	// FIXME: Implement this.
128	ASSERT_NOT_REACHED();
129	}	119	}
130		120
131	} // namespace WebKit	121	} // namespace WebKit

Lines 61-69 private: a/Source/WebKit/WebProcess/WebStorage/StorageAreaImpl.h_sec1
- a/Source/WebKit/WebProcess/WebStorage/StorageAreaImpl.h -3 / +1 lines
61	bool contains(const String& key) override;	61	bool contains(const String& key) override;
62	WebCore::StorageType storageType() const override;	62	WebCore::StorageType storageType() const override;
63	size_t memoryBytesUsedByCache() override;	63	size_t memoryBytesUsedByCache() override;
64	void incrementAccessCount() override;	64	void prewarm() final;
65	void decrementAccessCount() override;
66	void closeDatabaseIfIdle() override;
67		65
68	Identifier m_identifier;	66	Identifier m_identifier;
69	WeakPtr<StorageAreaMap> m_storageAreaMap;	67	WeakPtr<StorageAreaMap> m_storageAreaMap;

Lines 51-67 namespace WebKit { a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp_sec1
- a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp -45 / +81 lines
51	using namespace WebCore;	51	using namespace WebCore;
52		52
53	StorageAreaMap::StorageAreaMap(StorageNamespaceImpl& storageNamespace, Ref<WebCore::SecurityOrigin>&& securityOrigin)	53	StorageAreaMap::StorageAreaMap(StorageNamespaceImpl& storageNamespace, Ref<WebCore::SecurityOrigin>&& securityOrigin)
54	: m_namespace(storageNamespace)	54	: m_identifier(StorageAreaMapIdentifier::generate())
		55	, m_namespace(storageNamespace)
55	, m_securityOrigin(WTFMove(securityOrigin))	56	, m_securityOrigin(WTFMove(securityOrigin))
56	, m_quotaInBytes(storageNamespace.quotaInBytes())	57	, m_quotaInBytes(storageNamespace.quotaInBytes())
57	, m_type(storageNamespace.storageType())	58	, m_type(storageNamespace.storageType())
58	{	59	{
59	connect();	60	WebProcess::singleton().registerStorageAreaMap(*this);
60	}	61	}
61		62
62	StorageAreaMap::~StorageAreaMap()	63	StorageAreaMap::~StorageAreaMap()
63	{	64	{
64	disconnect();	65	disconnect();
		66	WebProcess::singleton().unregisterStorageAreaMap(*this);
65	}	67	}
66		68
67	unsigned StorageAreaMap::length()	69	unsigned StorageAreaMap::length()
Lines 95-102 void StorageAreaMap::setItem(Frame* sourceFrame, StorageAreaImpl* sourceArea, co a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp_sec2
95		97
96	m_pendingValueChanges.add(key);	98	m_pendingValueChanges.add(key);
97		99
98	if (m_mapID)	100	if (m_remoteAreaIdentifier)
99	WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::SetItem(*m_mapID, sourceArea->identifier(), m_currentSeed, key, value, sourceFrame->document()->url().string()), 0);	101	WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::SetItem(*m_remoteAreaIdentifier, sourceArea->identifier(), m_currentSeed, key, value, sourceFrame->document()->url().string()), 0);
100	else	102	else
101	RELEASE_LOG_ERROR(Storage, "StorageAreaMap::setItem failed because storage map ID is invalid");	103	RELEASE_LOG_ERROR(Storage, "StorageAreaMap::setItem failed because storage map ID is invalid");
102	}	104	}
Lines 114-136 void StorageAreaMap::removeItem(WebCore::Frame* sourceFrame, StorageAreaImpl* so a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp_sec3
114		116
115	m_pendingValueChanges.add(key);	117	m_pendingValueChanges.add(key);
116		118
117	if (m_mapID)	119	if (m_remoteAreaIdentifier)
118	WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::RemoveItem(*m_mapID, sourceArea->identifier(), m_currentSeed, key, sourceFrame->document()->url().string()), 0);	120	WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::RemoveItem(*m_remoteAreaIdentifier, sourceArea->identifier(), m_currentSeed, key, sourceFrame->document()->url().string()), 0);
119	else	121	else
120	RELEASE_LOG_ERROR(Storage, "StorageAreaMap::removeItem failed because storage map ID is invalid");	122	RELEASE_LOG_ERROR(Storage, "StorageAreaMap::removeItem failed because storage map ID is invalid");
121	}	123	}
122		124
123	void StorageAreaMap::clear(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceArea)	125	void StorageAreaMap::clear(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceArea)
124	{	126	{
125	connect();	127	connectSync();
126
127	resetValues();	128	resetValues();
128		129
129	m_hasPendingClear = true;	130	m_hasPendingClear = true;
130	m_map = makeUnique<StorageMap>(m_quotaInBytes);	131	m_map = makeUnique<StorageMap>(m_quotaInBytes);
131		132
132	if (m_mapID)	133	if (m_remoteAreaIdentifier)
133	WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::Clear(*m_mapID, sourceArea->identifier(), m_currentSeed, sourceFrame->document()->url().string()), 0);	134	WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkStorageManager::Clear(*m_remoteAreaIdentifier, sourceArea->identifier(), m_currentSeed, sourceFrame->document()->url().string()), 0);
134	else	135	else
135	RELEASE_LOG_ERROR(Storage, "StorageAreaMap::clear failed because storage map ID is invalid");	136	RELEASE_LOG_ERROR(Storage, "StorageAreaMap::clear failed because storage map ID is invalid");
136	}	137	}
Lines 151-171 void StorageAreaMap::resetValues() a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp_sec4
151		152
152	StorageMap& StorageAreaMap::ensureMap()	153	StorageMap& StorageAreaMap::ensureMap()
153	{	154	{
154	connect();	155	connectSync();
155		156
156	if (!m_map) {	157	if (!m_map)
157	m_map = makeUnique<StorageMap>(m_quotaInBytes);	158	m_map = makeUnique<StorageMap>(m_quotaInBytes);
158		159
159	if (m_mapID) {
160	// We need to use a IPC::UnboundedSynchronousIPCScope to prevent UIProcess hangs in case we receive a synchronous IPC from the UIProcess while we're waiting for a response
161	// from our StorageManagerSet::GetValues() IPC. This IPC may be very slow because it may need to fetch the values from disk and there may be a lot of data.
162	IPC::UnboundedSynchronousIPCScope unboundedSynchronousIPCScope;
163	HashMap<String, String> values;
164	WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::GetValues(*m_mapID), Messages::StorageManagerSet::GetValues::Reply(values), 0);
165	m_map->importItems(WTFMove(values));
166	} else
167	RELEASE_LOG_ERROR(Storage, "StorageAreaMap::ensureMap failed to load from network process because storage map ID is invalid");
168	}
169	return *m_map;	160	return *m_map;
170	}	161	}
171		162
Lines 259-266 void StorageAreaMap::applyChange(const String& key, const String& newValue) a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp_sec5
259	m_map->setItemIgnoringQuota(key, newValue);	250	m_map->setItemIgnoringQuota(key, newValue);
260	}	251	}
261		252
262	void StorageAreaMap::dispatchStorageEvent(const std::optional<StorageAreaImplIdentifier>& storageAreaImplID, const String& key, const String& oldValue, const String& newValue, const String& urlString)	253	void StorageAreaMap::dispatchStorageEvent(const std::optional<StorageAreaImplIdentifier>& storageAreaImplID, const String& key, const String& oldValue, const String& newValue, const String& urlString, uint64_t messageIdentifier)
263	{	254	{
		255	if (messageIdentifier < m_lastHandledMessageIdentifier)
		256	return;
		257
		258	m_lastHandledMessageIdentifier = messageIdentifier;
264	if (!storageAreaImplID) {	259	if (!storageAreaImplID) {
265	// This storage event originates from another process so we need to apply the change to our storage area map.	260	// This storage event originates from another process so we need to apply the change to our storage area map.
266	applyChange(key, newValue);	261	applyChange(key, newValue);
Lines 272-279 void StorageAreaMap::dispatchStorageEvent(const std::optional<StorageAreaImplIde a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp_sec6
272	dispatchLocalStorageEvent(storageAreaImplID, key, oldValue, newValue, urlString);	267	dispatchLocalStorageEvent(storageAreaImplID, key, oldValue, newValue, urlString);
273	}	268	}
274		269
275	void StorageAreaMap::clearCache()	270	void StorageAreaMap::clearCache(uint64_t messageIdentifier)
276	{	271	{
		272	if (messageIdentifier < m_lastHandledMessageIdentifier)
		273	return;
		274
		275	m_lastHandledMessageIdentifier = messageIdentifier;
277	resetValues();	276	resetValues();
278	}	277	}
279		278
Lines 344-385 void StorageAreaMap::dispatchLocalStorageEvent(const std::optional<StorageAreaIm a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp_sec7
344	StorageEventDispatcher::dispatchLocalStorageEventsToFrames(pageGroup, frames, key, oldValue, newValue, urlString, m_securityOrigin->data());	343	StorageEventDispatcher::dispatchLocalStorageEventsToFrames(pageGroup, frames, key, oldValue, newValue, urlString, m_securityOrigin->data());
345	}	344	}
346		345
		346	void StorageAreaMap::sendConnectMessage(SendMode mode)
		347	{
		348	auto& ipcConnection = WebProcess::singleton().ensureNetworkProcessConnection().connection();
		349	auto namespaceIdentifier = m_namespace.storageNamespaceID();
		350	auto originData = m_securityOrigin->data();
		351	auto topOriginData = m_namespace.topLevelOrigin() ? m_namespace.topLevelOrigin()->data() : originData;
		352	auto origin = WebCore::ClientOrigin { topOriginData, originData };
		353	auto type = m_type;
		354	if ((type == StorageType::Local \|\| type == StorageType::TransientLocal) && m_namespace.topLevelOrigin())
		355	type = StorageType::TransientLocal;
		356
		357	if (mode == SendMode::Sync) {
		358	StorageAreaIdentifier remoteAreaIdentifier;
		359	HashMap<String, String> items;
		360	uint64_t messageIdentifier;
		361	ipcConnection.sendSync(Messages::NetworkStorageManager::ConnectToStorageAreaSync(type, m_identifier, namespaceIdentifier, origin), Messages::NetworkStorageManager::ConnectToStorageAreaSync::Reply(remoteAreaIdentifier, items, messageIdentifier), 0);
		362	didConnect(remoteAreaIdentifier, WTFMove(items), messageIdentifier);
		363	return;
		364	}
		365
		366	auto completionHandler = [this, weakThis = WeakPtr { *this }, weakConnection = WeakPtr { ipcConnection }](auto remoteAreaIdentifier, auto items, auto messageIdentifier) mutable {
		367	if (weakThis)
		368	return didConnect(remoteAreaIdentifier, WTFMove(items), messageIdentifier);
		369
		370	if (weakConnection && remoteAreaIdentifier.isValid())
		371	weakConnection->send(Messages::NetworkStorageManager::DisconnectFromStorageArea(remoteAreaIdentifier), 0);
		372	};
		373
		374	ipcConnection.sendWithAsyncReply(Messages::NetworkStorageManager::ConnectToStorageArea(type, m_identifier, namespaceIdentifier, origin), WTFMove(completionHandler));
		375	}
		376
		377	void StorageAreaMap::connectSync()
		378	{
		379	if (m_remoteAreaIdentifier)
		380	return;
		381
		382	sendConnectMessage(SendMode::Sync);
		383	}
		384
347	void StorageAreaMap::connect()	385	void StorageAreaMap::connect()
348	{	386	{
349	if (m_mapID)	387	if (m_remoteAreaIdentifier)
350	return;	388	return;
351		389
352	StorageAreaIdentifier mapID;	390	sendConnectMessage(SendMode::Async);
353	switch (m_type) {	391	}
354	case StorageType::Local:
355	case StorageType::TransientLocal:
356	if (SecurityOrigin* topLevelOrigin = m_namespace.topLevelOrigin())
357	WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::ConnectToTransientLocalStorageArea(m_namespace.storageNamespaceID(), topLevelOrigin->data(), m_securityOrigin->data()), Messages::NetworkStorageManager::ConnectToTransientLocalStorageArea::Reply(mapID), 0);
358	else
359	WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::ConnectToLocalStorageArea(m_namespace.storageNamespaceID(), m_securityOrigin->data()), Messages::NetworkStorageManager::ConnectToLocalStorageArea::Reply(mapID), 0);
360	break;
361	case StorageType::Session:
362	WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkStorageManager::ConnectToSessionStorageArea(m_namespace.storageNamespaceID(), m_securityOrigin->data()), Messages::NetworkStorageManager::ConnectToSessionStorageArea::Reply(mapID), 0);
363	}
364		392
365	if (mapID.isValid()) {	393	void StorageAreaMap::didConnect(StorageAreaIdentifier remoteAreaIdentifier, HashMap<String, String>&& items, uint64_t messageIdentifier)
366	m_mapID = mapID;	394	{
367	WebProcess::singleton().registerStorageAreaMap(*this);	395	if (messageIdentifier < m_lastHandledMessageIdentifier)
368	}	396	return;
		397
		398	m_lastHandledMessageIdentifier = messageIdentifier;
		399	if (!remoteAreaIdentifier.isValid())
		400	return;
		401
		402	m_remoteAreaIdentifier = remoteAreaIdentifier;
		403	m_map = makeUnique<StorageMap>(m_quotaInBytes);
		404	m_map->importItems(WTFMove(items));
369	}	405	}
370		406
371	void StorageAreaMap::disconnect()	407	void StorageAreaMap::disconnect()
372	{	408	{
373	if (!m_mapID)	409	if (!m_remoteAreaIdentifier)
374	return;	410	return;
375		411
376	resetValues();	412	resetValues();
377	WebProcess::singleton().unregisterStorageAreaMap(*this);
378		413
379	if (auto* networkProcessConnection = WebProcess::singleton().existingNetworkProcessConnection())	414	if (auto* networkProcessConnection = WebProcess::singleton().existingNetworkProcessConnection())
380	networkProcessConnection->connection().send(Messages::NetworkStorageManager::DisconnectFromStorageArea(*m_mapID), 0);	415	networkProcessConnection->connection().send(Messages::NetworkStorageManager::DisconnectFromStorageArea(*m_remoteAreaIdentifier), 0);
381		416
382	m_mapID = { };	417	m_remoteAreaIdentifier = { };
		418	m_lastHandledMessageIdentifier = 0;
383	}	419	}
384		420
385	void StorageAreaMap::incrementUseCount()	421	void StorageAreaMap::incrementUseCount()

Lines 28-33 a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h_sec1
- a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h -5 / +12 lines
28	#include "MessageReceiver.h"	28	#include "MessageReceiver.h"
29	#include "StorageAreaIdentifier.h"	29	#include "StorageAreaIdentifier.h"
30	#include "StorageAreaImplIdentifier.h"	30	#include "StorageAreaImplIdentifier.h"
		31	#include "StorageAreaMapIdentifier.h"
31	#include <WebCore/SecurityOrigin.h>	32	#include <WebCore/SecurityOrigin.h>
32	#include <WebCore/StorageArea.h>	33	#include <WebCore/StorageArea.h>
33	#include <wtf/Forward.h>	34	#include <wtf/Forward.h>
Lines 66-73 public: a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h_sec2
66	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;	67	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
67		68
68	const WebCore::SecurityOrigin& securityOrigin() const { return m_securityOrigin.get(); }	69	const WebCore::SecurityOrigin& securityOrigin() const { return m_securityOrigin.get(); }
69	const std::optional<StorageAreaIdentifier>& identifier() const { return m_mapID; }	70	StorageAreaMapIdentifier identifier() const { return m_identifier; }
70		71
		72	void connect();
71	void disconnect();	73	void disconnect();
72		74
73	void incrementUseCount();	75	void incrementUseCount();
Lines 78-85 private: a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h_sec3
78	void didRemoveItem(uint64_t mapSeed, const String& key);	80	void didRemoveItem(uint64_t mapSeed, const String& key);
79	void didClear(uint64_t mapSeed);	81	void didClear(uint64_t mapSeed);
80		82
81	void dispatchStorageEvent(const std::optional<StorageAreaImplIdentifier>& sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString);	83	void dispatchStorageEvent(const std::optional<StorageAreaImplIdentifier>& sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString, uint64_t messageIdentifier);
82	void clearCache();	84	void clearCache(uint64_t messageIdentifier);
83		85
84	void resetValues();	86	void resetValues();
85	WebCore::StorageMap& ensureMap();	87	WebCore::StorageMap& ensureMap();
Lines 90-101 private: a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h_sec4
90	void dispatchSessionStorageEvent(const std::optional<StorageAreaImplIdentifier>&, const String& key, const String& oldValue, const String& newValue, const String& urlString);	92	void dispatchSessionStorageEvent(const std::optional<StorageAreaImplIdentifier>&, const String& key, const String& oldValue, const String& newValue, const String& urlString);
91	void dispatchLocalStorageEvent(const std::optional<StorageAreaImplIdentifier>&, const String& key, const String& oldValue, const String& newValue, const String& urlString);	93	void dispatchLocalStorageEvent(const std::optional<StorageAreaImplIdentifier>&, const String& key, const String& oldValue, const String& newValue, const String& urlString);
92		94
93	void connect();	95	enum class SendMode : bool { Async, Sync };
		96	void sendConnectMessage(SendMode);
		97	void connectSync();
		98	void didConnect(StorageAreaIdentifier, HashMap<String, String>&&, uint64_t messageIdentifier);
94		99
		100	StorageAreaMapIdentifier m_identifier;
		101	uint64_t m_lastHandledMessageIdentifier { 0 };
95	StorageNamespaceImpl& m_namespace;	102	StorageNamespaceImpl& m_namespace;
96	Ref<WebCore::SecurityOrigin> m_securityOrigin;	103	Ref<WebCore::SecurityOrigin> m_securityOrigin;
97	std::unique_ptr<WebCore::StorageMap> m_map;	104	std::unique_ptr<WebCore::StorageMap> m_map;
98	std::optional<StorageAreaIdentifier> m_mapID;	105	std::optional<StorageAreaIdentifier> m_remoteAreaIdentifier;
99	HashCountedSet<String> m_pendingValueChanges;	106	HashCountedSet<String> m_pendingValueChanges;
100	uint64_t m_currentSeed { 0 };	107	uint64_t m_currentSeed { 0 };
101	unsigned m_quotaInBytes;	108	unsigned m_quotaInBytes;

Line 0 a/Source/WebKit/WebProcess/WebStorage/StorageAreaMapIdentifier.h_sec1
- a/Source/WebKit/WebProcess/WebStorage/StorageAreaMapIdentifier.h +36 lines
	1	/*
	2	* Copyright (C) 2022 Apple Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	23	* THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#pragma once
	27
	28	#include <wtf/ObjectIdentifier.h>
	29
	30	namespace WebKit {
	31
	32	enum StorageAreaMapIdentifierType { };
	33	using StorageAreaMapIdentifier = ObjectIdentifier<StorageAreaMapIdentifierType>;
	34
	35	} // namespace WebKit
	36