Attachment #450867 for bug #234925

View Details Raw Unified Return to Bug 234925

| Differences between



2022-02-03  Sihui Liu  <sihui_liu@apple.com>

        Manage IndexedDB storage by origin
        https://bugs.webkit.org/show_bug.cgi?id=234925
        <rdar://problem/87555014>

        Reviewed by NOBODY (OOPS!).

        Add a helper function to get the target from a symoblic link path.

        * wtf/FileSystem.cpp:
        (WTF::FileSystemImpl::getSymbolicLinkTarget):
        * wtf/FileSystem.h:

2022-02-03  Robert Jenner  <Jenner@apple.com>

        Unreviewed, reverting r288902.



2022-02-03  Sihui Liu  <sihui_liu@apple.com>

        Manage IndexedDB storage by origin
        https://bugs.webkit.org/show_bug.cgi?id=234925
        <rdar://problem/87555014>

        Reviewed by NOBODY (OOPS!).

        Both WebKit and WebKitLegacy used IDBServer to manage UniqueIDBDatabases, and UniqueIDBDatabase pointed to 
        IDBServer. Now that WebKit uses WebKit::IDBStorageManager to manage UniqueIDBDatabases. We untie the 
        knot between IDBServer and UniqueIDBDatabase by adding a new abstract class UniqueIDBDatabaseManager and make
        UniqueIDBDatabase point to UniqueIDBDatabaseManager.

        Also, as quota check is no longer async according to changes in WebKit, we need to update operations in
        UniqueIDBDatabase to adopt the change.

        Covered by existing tests.

        * Headers.cmake:
        * Modules/indexeddb/IDBDatabaseIdentifier.h:
        * Modules/indexeddb/server/IDBConnectionToClient.h:
        * Modules/indexeddb/server/IDBServer.cpp:
        (WebCore::IDBServer::IDBServer::registerConnection):
        (WebCore::IDBServer::IDBServer::unregisterConnection):
        (WebCore::IDBServer::IDBServer::createBackingStore):
        (WebCore::IDBServer::IDBServer::upgradedDatabaseDirectory):
        (WebCore::IDBServer::IDBServer::registerDatabaseConnection): Deleted.
        (WebCore::IDBServer::IDBServer::unregisterDatabaseConnection): Deleted.
        (WebCore::IDBServer::IDBServer::closeAndTakeUniqueIDBDatabase): Deleted.
        * Modules/indexeddb/server/IDBServer.h:
        * Modules/indexeddb/server/MemoryIDBBackingStore.cpp:
        (WebCore::IDBServer::MemoryIDBBackingStore::MemoryIDBBackingStore):
        (WebCore::IDBServer::MemoryIDBBackingStore::createObjectStore):
        * Modules/indexeddb/server/MemoryIDBBackingStore.h:
        * Modules/indexeddb/server/MemoryObjectStore.cpp:
        (WebCore::IDBServer::MemoryObjectStore::create):
        (WebCore::IDBServer::MemoryObjectStore::MemoryObjectStore):
        * Modules/indexeddb/server/MemoryObjectStore.h:
        * Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
        (WebCore::IDBServer::SQLiteIDBBackingStore::SQLiteIDBBackingStore):
        (WebCore::IDBServer::SQLiteIDBBackingStore::encodeDatabaseName):
        (WebCore::IDBServer::SQLiteIDBBackingStore::decodeDatabaseName):
        (WebCore::IDBServer::SQLiteIDBBackingStore::getOrEstablishDatabaseInfo):
        (WebCore::IDBServer::SQLiteIDBBackingStore::deleteBackingStore):
        (WebCore::IDBServer::SQLiteIDBBackingStore::filenameForDatabaseName const): Deleted.
        (WebCore::IDBServer::SQLiteIDBBackingStore::fullDatabaseDirectoryWithUpgrade): Deleted.
        * Modules/indexeddb/server/SQLiteIDBBackingStore.h:
        * Modules/indexeddb/server/UniqueIDBDatabase.cpp:
        (WebCore::IDBServer::UniqueIDBDatabase::UniqueIDBDatabase):
        (WebCore::IDBServer::UniqueIDBDatabase::manager):
        (WebCore::IDBServer::UniqueIDBDatabase::performCurrentOpenOperation):
        (WebCore::IDBServer::UniqueIDBDatabase::performCurrentOpenOperationAfterSpaceCheck):
        (WebCore::IDBServer::UniqueIDBDatabase::deleteBackingStore):
        (WebCore::IDBServer::UniqueIDBDatabase::createObjectStore):
        (WebCore::IDBServer::UniqueIDBDatabase::deleteObjectStore):
        (WebCore::IDBServer::UniqueIDBDatabase::renameObjectStore):
        (WebCore::IDBServer::UniqueIDBDatabase::clearObjectStore):
        (WebCore::IDBServer::UniqueIDBDatabase::createIndex):
        (WebCore::IDBServer::UniqueIDBDatabase::deleteIndex):
        (WebCore::IDBServer::UniqueIDBDatabase::renameIndex):
        (WebCore::IDBServer::UniqueIDBDatabase::putOrAdd):
        (WebCore::IDBServer::UniqueIDBDatabase::putOrAddAfterSpaceCheck):
        (WebCore::IDBServer::UniqueIDBDatabase::getRecord):
        (WebCore::IDBServer::UniqueIDBDatabase::getAllRecords):
        (WebCore::IDBServer::UniqueIDBDatabase::getCount):
        (WebCore::IDBServer::UniqueIDBDatabase::deleteRecord):
        (WebCore::IDBServer::UniqueIDBDatabase::openCursor):
        (WebCore::IDBServer::UniqueIDBDatabase::iterateCursor):
        (WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):
        (WebCore::IDBServer::UniqueIDBDatabase::abortTransaction):
        (WebCore::IDBServer::UniqueIDBDatabase::abortInProgressTransactions):
        (WebCore::IDBServer::UniqueIDBDatabase::hasDataInMemory const):
        * Modules/indexeddb/server/UniqueIDBDatabase.h:
        (WebCore::IDBServer::UniqueIDBDatabase::server): Deleted.
        * Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp:
        (WebCore::IDBServer::UniqueIDBDatabaseConnection::UniqueIDBDatabaseConnection):
        (WebCore::IDBServer::UniqueIDBDatabaseConnection::~UniqueIDBDatabaseConnection):
        (WebCore::IDBServer::UniqueIDBDatabaseConnection::manager):
        * Modules/indexeddb/server/UniqueIDBDatabaseConnection.h:
        (WebCore::IDBServer::UniqueIDBDatabaseConnection::server): Deleted.
        * Modules/indexeddb/server/UniqueIDBDatabaseManager.h: Added.
        (WebCore::IDBServer::UniqueIDBDatabaseManager::~UniqueIDBDatabaseManager):
        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp:
        (WebCore::IDBServer::UniqueIDBDatabaseTransaction::UniqueIDBDatabaseTransaction):
        (WebCore::IDBServer::UniqueIDBDatabaseTransaction::~UniqueIDBDatabaseTransaction):
        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h:
        * Modules/indexeddb/shared/IDBError.h:
        (WebCore::IDBError::operator bool const):
        * Modules/indexeddb/shared/IDBRequestData.h:
        * Modules/indexeddb/shared/IDBResourceIdentifier.h:
        (WebCore::IDBResourceIdentifier::operator!= const):
        * WebCore.xcodeproj/project.pbxproj:

2022-02-03  Ben Nham  <nham@apple.com>

        LocalStorage values should be 8-bit strings in memory if possible



2022-02-03  Sihui Liu  <sihui_liu@apple.com>

        Manage IndexedDB storage by origin
        https://bugs.webkit.org/show_bug.cgi?id=234925
        <rdar://problem/87555014>

        Reviewed by NOBODY (OOPS!).

        In network process, IndexedDB data is managed by WebKit::WebIDBServer. Each session owns a WebIDBServer 
        (IDBServer) and each IDBServer owns one or more UniqueIDBDatabases (resprenting one actual database that
        IDBDatabase connects to, can be identified by {session, origin, name}). Now that we have NetworkStorageManager, 
        which manages session storage by origin, we can merge WebIDBServer with NetworkStorageManager, since IndexedDB 
        storage is not shared across origins.

        The old structure is:
        NetworkSession - WebIDBServer - IDBServer - UniqueIDBDatabases
        The new structure is:
        NetworkSession - NetworkStorageManager - OriginStorageManager - IDBStorageManager - UniqueIDBDatabase

        To complete this transition, we need to make a few changes:
        1. Web process now sends IndexedDB related messages to NetworkStorageManager instead of WebIDBServer. 
        2. Some messages are sent to operate on UniqueIDBDatabaseConnection or UniqueIDBDatabaseTransaction, and they 
        use identifiers to specify the target. Therefore, NetworkStorageManagers needs to know the mapping between 
        identifiers and target objects. We add a new IDBStorageRegistry class to record this mapping. Each 
        NetworkStorageManager owns a IDBStorageRegistry and it passes IDBStorageRegistry to IDBStorageManager,
        IDBStorageManager will register objects to IDBStorageRegistry and NetworkStorageManager can do search via 
        IDBStorageRegistry.
        3. Quota check for IndexedDB operations becomes async by adding new QuotaManager class, which is similar to 
        WebCore::StorageQuotaManager but provides async interfaces. 
        We used to block the IDBServer thread when it is waiting for quota check result from UI process, this is fine 
        because IDBServer runs on its own thread. Now that IDBStorageManager runs on the same thread as the other 
        storage types, we cannot block the thread on quota check.
        4. Rename WebIDBConnectionToClient to IDBStorageConnectionToClient to reflect the change on the structure. Also,
        IDBStorageConnectionToClient does not keep reference to the IPC::Connection now, it only records 
        IPC::Connection::UniqueID.
        5. IndexedDB data may be put in different version dirctories. We used to migrate database to new version 
        diretory when the database is accessed. As IDBStorageManager now manages IndexedDB data of one origin, it's 
        simpler if it only keeps track of one directory. Therefore, we now migrate all databases of one origin
        when the origin is accessed (see IDBStorageManager::idbStorageOriginDirectory). 

        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
        (WebKit::NetworkConnectionToWebProcess::updateQuotaBasedOnSpaceUsageForTesting):
        (WebKit::NetworkConnectionToWebProcess::writeBlobsToTemporaryFilesForIndexedDB):
        * NetworkProcess/NetworkProcess.cpp:
        (WebKit::NetworkProcess::didClose):
        (WebKit::NetworkProcess::createNetworkConnectionToWebProcess):
        (WebKit::NetworkProcess::addWebsiteDataStore):
        (WebKit::NetworkProcess::fetchWebsiteData):
        (WebKit::NetworkProcess::deleteWebsiteData):
        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
        (WebKit::NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains):
        (WebKit::NetworkProcess::registrableDomainsWithWebsiteData):
        (WebKit::NetworkProcess::prepareToSuspend):
        (WebKit::NetworkProcess::resume):
        (WebKit::NetworkProcess::resetQuota):
        (WebKit::NetworkProcess::didIncreaseQuota):
        (WebKit::NetworkProcess::renameOriginInWebsiteData):
        (WebKit::NetworkProcess::storageQuotaManager):
        (WebKit::NetworkProcess::connectionToWebProcessClosed):
        (WebKit::NetworkProcess::suspendIDBServers): Deleted.
        * NetworkProcess/NetworkProcess.h:
        (WebKit::NetworkProcess::shouldSuspendIDBServers const): Deleted.
        * NetworkProcess/NetworkProcess.messages.in:
        * NetworkProcess/NetworkSession.cpp:
        (WebKit::NetworkSession::invalidateAndCancel):
        (WebKit::NetworkSession::addStorageManagerSession):
        (WebKit::NetworkSession::ensureWebIDBServer): Deleted.
        (WebKit::NetworkSession::closeIDBServer): Deleted.
        (WebKit::NetworkSession::addIndexedDatabaseSession): Deleted.
        * NetworkProcess/NetworkSession.h:
        (WebKit::NetworkSession::webIDBServer): Deleted.
        (WebKit::NetworkSession::hasIDBDatabasePath const): Deleted.
        * NetworkProcess/cache/CacheStorageEngine.cpp:
        (WebKit::CacheStorage::Engine::storagePath):
        (WebKit::CacheStorage::Engine::diskUsage):
        (WebKit::CacheStorage::Engine::requestSpace):
        * NetworkProcess/cache/CacheStorageEngine.h:
        * NetworkProcess/cache/CacheStorageEngineCaches.cpp:
        (WebKit::CacheStorage::Caches::requestSpace):
        * NetworkProcess/ios/NetworkProcessIOS.mm:
        (WebKit::NetworkProcess::setIsHoldingLockedFiles):
        * NetworkProcess/storage/IDBStorageConnectionToClient.cpp: Added.
        (WebKit::IDBStorageConnectionToClient::IDBStorageConnectionToClient):
        (WebKit::IDBStorageConnectionToClient::~IDBStorageConnectionToClient):
        (WebKit::IDBStorageConnectionToClient::connectionToClient):
        (WebKit::IDBStorageConnectionToClient::didGetResult):
        (WebKit::IDBStorageConnectionToClient::didDeleteDatabase):
        (WebKit::IDBStorageConnectionToClient::didOpenDatabase):
        (WebKit::IDBStorageConnectionToClient::didStartTransaction):
        (WebKit::IDBStorageConnectionToClient::didAbortTransaction):
        (WebKit::IDBStorageConnectionToClient::didCommitTransaction):
        (WebKit::IDBStorageConnectionToClient::didCreateObjectStore):
        (WebKit::IDBStorageConnectionToClient::didDeleteObjectStore):
        (WebKit::IDBStorageConnectionToClient::didRenameObjectStore):
        (WebKit::IDBStorageConnectionToClient::didClearObjectStore):
        (WebKit::IDBStorageConnectionToClient::didCreateIndex):
        (WebKit::IDBStorageConnectionToClient::didDeleteIndex):
        (WebKit::IDBStorageConnectionToClient::didRenameIndex):
        (WebKit::IDBStorageConnectionToClient::didPutOrAdd):
        (WebKit::IDBStorageConnectionToClient::didGetRecord):
        (WebKit::IDBStorageConnectionToClient::didGetAllRecords):
        (WebKit::IDBStorageConnectionToClient::didGetCount):
        (WebKit::IDBStorageConnectionToClient::didDeleteRecord):
        (WebKit::IDBStorageConnectionToClient::didOpenCursor):
        (WebKit::IDBStorageConnectionToClient::didIterateCursor):
        (WebKit::IDBStorageConnectionToClient::didGetAllDatabaseNamesAndVersions):
        (WebKit::IDBStorageConnectionToClient::fireVersionChangeEvent):
        (WebKit::IDBStorageConnectionToClient::didCloseFromServer):
        (WebKit::IDBStorageConnectionToClient::notifyOpenDBRequestBlocked):
        * NetworkProcess/storage/IDBStorageConnectionToClient.h: Added.
        * NetworkProcess/storage/IDBStorageManager.cpp: Added.
        (WebKit::migrateOriginData):
        (WebKit::IDBStorageManager::idbStorageOriginDirectory):
        (WebKit::IDBStorageManager::idbStorageSize):
        (WebKit::getOriginsForVersion):
        (WebKit::IDBStorageManager::originsOfIDBStorageData):
        (WebKit::IDBStorageManager::IDBStorageManager):
        (WebKit::IDBStorageManager::isActive const):
        (WebKit::IDBStorageManager::hasDataInMemory const):
        (WebKit::IDBStorageManager::closeDatabasesForDeletion):
        (WebKit::IDBStorageManager::stopDatabaseActivitiesForSuspend):
        (WebKit::IDBStorageManager::getOrCreateUniqueIDBDatabase):
        (WebKit::IDBStorageManager::openDatabase):
        (WebKit::IDBStorageManager::deleteDatabase):
        (WebKit::IDBStorageManager::getAllDatabaseNamesAndVersions):
        (WebKit::IDBStorageManager::openDBRequestCancelled):
        (WebKit::IDBStorageManager::registerConnection):
        (WebKit::IDBStorageManager::unregisterConnection):
        (WebKit::IDBStorageManager::registerTransaction):
        (WebKit::IDBStorageManager::unregisterTransaction):
        (WebKit::IDBStorageManager::createBackingStore):
        (WebKit::IDBStorageManager::requestSpace):
        * NetworkProcess/storage/IDBStorageManager.h: Added.
        * NetworkProcess/storage/IDBStorageRegistry.cpp: Added.
        (WebKit::IDBStorageRegistry::getOrCreateConnectionToClient):
        (WebKit::IDBStorageRegistry::removeConnectionToClient):
        (WebKit::IDBStorageRegistry::registerConnection):
        (WebKit::IDBStorageRegistry::unregisterConnection):
        (WebKit::IDBStorageRegistry::registerTransaction):
        (WebKit::IDBStorageRegistry::unregisterTransaction):
        (WebKit::IDBStorageRegistry::getConnection):
        (WebKit::IDBStorageRegistry::getTransaction):
        * NetworkProcess/storage/IDBStorageRegistry.h: Added.
        * NetworkProcess/storage/NetworkStorageManager.cpp:
        (WebKit::NetworkStorageManager::create):
        (WebKit::NetworkStorageManager::NetworkStorageManager):
        (WebKit::NetworkStorageManager::canHandleTypes):
        (WebKit::NetworkStorageManager::stopReceivingMessageFromConnection):
        (WebKit::NetworkStorageManager::localOriginStorageManager):
        (WebKit::NetworkStorageManager::didIncreaseQuota):
        (WebKit::NetworkStorageManager::getAllOrigins):
        (WebKit::NetworkStorageManager::moveData):
        (WebKit::NetworkStorageManager::suspend):
        (WebKit::NetworkStorageManager::registerTemporaryBlobFilePaths):
        (WebKit::NetworkStorageManager::requestSpace):
        (WebKit::NetworkStorageManager::resetQuotaForTesting):
        (WebKit::NetworkStorageManager::resetQuotaUpdatedBasedOnUsageForTesting):
        (WebKit::NetworkStorageManager::openDatabase):
        (WebKit::NetworkStorageManager::openDBRequestCancelled):
        (WebKit::NetworkStorageManager::deleteDatabase):
        (WebKit::NetworkStorageManager::establishTransaction):
        (WebKit::NetworkStorageManager::databaseConnectionPendingClose):
        (WebKit::NetworkStorageManager::databaseConnectionClosed):
        (WebKit::NetworkStorageManager::abortOpenAndUpgradeNeeded):
        (WebKit::NetworkStorageManager::didFireVersionChangeEvent):
        (WebKit::NetworkStorageManager::abortTransaction):
        (WebKit::NetworkStorageManager::commitTransaction):
        (WebKit::NetworkStorageManager::didFinishHandlingVersionChangeTransaction):
        (WebKit::NetworkStorageManager::createObjectStore):
        (WebKit::NetworkStorageManager::deleteObjectStore):
        (WebKit::NetworkStorageManager::renameObjectStore):
        (WebKit::NetworkStorageManager::clearObjectStore):
        (WebKit::NetworkStorageManager::createIndex):
        (WebKit::NetworkStorageManager::deleteIndex):
        (WebKit::NetworkStorageManager::renameIndex):
        (WebKit::NetworkStorageManager::putOrAdd):
        (WebKit::NetworkStorageManager::getRecord):
        (WebKit::NetworkStorageManager::getAllRecords):
        (WebKit::NetworkStorageManager::getCount):
        (WebKit::NetworkStorageManager::deleteRecord):
        (WebKit::NetworkStorageManager::openCursor):
        (WebKit::NetworkStorageManager::iterateCursor):
        (WebKit::NetworkStorageManager::getAllDatabaseNamesAndVersions):
        * NetworkProcess/storage/NetworkStorageManager.h:
        * NetworkProcess/storage/NetworkStorageManager.messages.in:
        * NetworkProcess/storage/OriginStorageManager.cpp:
        (WebKit::OriginStorageManager::StorageBucket::StorageBucket):
        (WebKit::OriginStorageManager::StorageBucket::toWebsiteDataType):
        (WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier):
        (WebKit::OriginStorageManager::StorageBucket::idbStorageManager):
        (WebKit::OriginStorageManager::StorageBucket::existingIDBStorageManager):
        (WebKit::OriginStorageManager::StorageBucket::isActive const):
        (WebKit::OriginStorageManager::StorageBucket::isEmpty const):
        (WebKit::OriginStorageManager::StorageBucket::deleteData):
        (WebKit::OriginStorageManager::StorageBucket::moveData):
        (WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromMemory):
        (WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromDisk):
        (WebKit::OriginStorageManager::StorageBucket::deleteIDBStorageData):
        (WebKit::createQuotaManager):
        (WebKit::OriginStorageManager::OriginStorageManager):
        (WebKit::OriginStorageManager::defaultBucket):
        (WebKit::OriginStorageManager::quotaManager):
        (WebKit::OriginStorageManager::idbStorageManager):
        (WebKit::OriginStorageManager::existingIDBStorageManager):
        (WebKit::OriginStorageManager::moveData):
        * NetworkProcess/storage/OriginStorageManager.h:
        * NetworkProcess/storage/QuotaManager.cpp: Added.
        (WebKit::QuotaManager::create):
        (WebKit::QuotaManager::QuotaManager):
        (WebKit::QuotaManager::requestSpace):
        (WebKit::QuotaManager::handleRequests):
        (WebKit::QuotaManager::grantWithCurrentQuota):
        (WebKit::QuotaManager::grantFastPath):
        (WebKit::QuotaManager::didIncreaseQuota):
        (WebKit::QuotaManager::resetQuotaUpdatedBasedOnUsageForTesting):
        (WebKit::QuotaManager::resetQuotaForTesting):
        * NetworkProcess/storage/QuotaManager.h: Added.
        * Scripts/webkit/messages.py:
        (types_that_cannot_be_forward_declared):
        * Shared/WebsiteData/QuotaIncreaseRequestIdentifier.h: Added.
        * Shared/WebsiteDataStoreParameters.h:
        * Sources.txt:
        * UIProcess/Network/NetworkProcessProxy.cpp:
        (WebKit::NetworkProcessProxy::increaseQuota):
        * UIProcess/Network/NetworkProcessProxy.h:
        * UIProcess/Network/NetworkProcessProxy.messages.in:
        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
        (WebKit::WebsiteDataStore::perThirdPartyOriginStorageQuota const):
        * UIProcess/WebsiteData/WebsiteDataStore.h:
        (WebKit::WebsiteDataStore::defaultPerOriginQuota):
        * UIProcess/WebsiteData/WebsiteDataStoreConfiguration.cpp:
        (WebKit::WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration):
        * UIProcess/WebsiteData/WebsiteDataStoreConfiguration.h:
        * WebKit.xcodeproj/project.pbxproj:
        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
        (WebKit::WebIDBConnectionToServer::deleteDatabase):
        (WebKit::WebIDBConnectionToServer::openDatabase):
        (WebKit::WebIDBConnectionToServer::abortTransaction):
        (WebKit::WebIDBConnectionToServer::commitTransaction):
        (WebKit::WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
        (WebKit::WebIDBConnectionToServer::createObjectStore):
        (WebKit::WebIDBConnectionToServer::deleteObjectStore):
        (WebKit::WebIDBConnectionToServer::renameObjectStore):
        (WebKit::WebIDBConnectionToServer::clearObjectStore):
        (WebKit::WebIDBConnectionToServer::createIndex):
        (WebKit::WebIDBConnectionToServer::deleteIndex):
        (WebKit::WebIDBConnectionToServer::renameIndex):
        (WebKit::WebIDBConnectionToServer::putOrAdd):
        (WebKit::WebIDBConnectionToServer::getRecord):
        (WebKit::WebIDBConnectionToServer::getAllRecords):
        (WebKit::WebIDBConnectionToServer::getCount):
        (WebKit::WebIDBConnectionToServer::deleteRecord):
        (WebKit::WebIDBConnectionToServer::openCursor):
        (WebKit::WebIDBConnectionToServer::iterateCursor):
        (WebKit::WebIDBConnectionToServer::establishTransaction):
        (WebKit::WebIDBConnectionToServer::databaseConnectionPendingClose):
        (WebKit::WebIDBConnectionToServer::databaseConnectionClosed):
        (WebKit::WebIDBConnectionToServer::abortOpenAndUpgradeNeeded):
        (WebKit::WebIDBConnectionToServer::didFireVersionChangeEvent):
        (WebKit::WebIDBConnectionToServer::openDBRequestCancelled):
        (WebKit::WebIDBConnectionToServer::getAllDatabaseNamesAndVersions):

2022-02-03  Sihui Liu  <sihui_liu@apple.com>

        Delay writing origin file in NetworkStorageManager



2022-02-03  Sihui Liu  <sihui_liu@apple.com>

        Manage IndexedDB storage by origin
        https://bugs.webkit.org/show_bug.cgi?id=234925
        <rdar://problem/87555014>

        Reviewed by NOBODY (OOPS!).

        * Storage/InProcessIDBServer.cpp:
        (InProcessIDBServer::quotaManager):

2022-02-02  Elliott Williams  <emw@apple.com>

        [Xcode] Fix redundant execution of "Check VTables..." script

Lines 660-665 bool createSymbolicLink(const String& targetPath, const String& symbolicLinkPath a/Source/WTF/wtf/FileSystem.cpp_sec1
- a/Source/WTF/wtf/FileSystem.cpp +9 lines
660	return !ec;	660	return !ec;
661	}	661	}
662		662
		663	String getSymbolicLinkTarget(const String& symbolicLinkPath)
		664	{
		665	auto fileSystemPath = toStdFileSystemPath(symbolicLinkPath);
		666	if (!std::filesystem::is_symlink(fileSystemPath))
		667	return symbolicLinkPath;
		668
		669	return fromStdFileSystemPath(std::filesystem::read_symlink(fileSystemPath));
		670	}
		671
663	bool hardLink(const String& targetPath, const String& linkPath)	672	bool hardLink(const String& targetPath, const String& linkPath)
664	{	673	{
665	std::error_code ec;	674	std::error_code ec;

Lines 127-132 WTF_EXPORT_PRIVATE std::optional<uint64_t> volumeFreeSpace(const String&); a/Source/WTF/wtf/FileSystem.h_sec1
- a/Source/WTF/wtf/FileSystem.h +1 lines
127	WTF_EXPORT_PRIVATE std::optional<uint32_t> volumeFileBlockSize(const String&);	127	WTF_EXPORT_PRIVATE std::optional<uint32_t> volumeFileBlockSize(const String&);
128	WTF_EXPORT_PRIVATE std::optional<int32_t> getFileDeviceId(const CString&);	128	WTF_EXPORT_PRIVATE std::optional<int32_t> getFileDeviceId(const CString&);
129	WTF_EXPORT_PRIVATE bool createSymbolicLink(const String& targetPath, const String& symbolicLinkPath);	129	WTF_EXPORT_PRIVATE bool createSymbolicLink(const String& targetPath, const String& symbolicLinkPath);
		130	WTF_EXPORT_PRIVATE String getSymbolicLinkTarget(const String& symbolicLinkPath);
130	WTF_EXPORT_PRIVATE String createTemporaryZipArchive(const String& directory);	131	WTF_EXPORT_PRIVATE String createTemporaryZipArchive(const String& directory);
131		132
132	enum class FileType { Regular, Directory, SymbolicLink };	133	enum class FileType { Regular, Directory, SymbolicLink };

Lines 82-88 public: a/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h_sec1
- a/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h -1 / +1 lines
82	bool isTransient() const { return m_isTransient; }	82	bool isTransient() const { return m_isTransient; }
83		83
84	String databaseDirectoryRelativeToRoot(const String& rootDirectory, const String& versionString="v1") const;	84	String databaseDirectoryRelativeToRoot(const String& rootDirectory, const String& versionString="v1") const;
85	static String databaseDirectoryRelativeToRoot(const SecurityOriginData& topLevelOrigin, const SecurityOriginData& openingOrigin, const String& rootDirectory, const String& versionString);	85	WEBCORE_EXPORT static String databaseDirectoryRelativeToRoot(const SecurityOriginData& topLevelOrigin, const SecurityOriginData& openingOrigin, const String& rootDirectory, const String& versionString);
86		86
87	template<class Encoder> void encode(Encoder&) const;	87	template<class Encoder> void encode(Encoder&) const;
88	template<class Decoder> static std::optional<IDBDatabaseIdentifier> decode(Decoder&);	88	template<class Decoder> static std::optional<IDBDatabaseIdentifier> decode(Decoder&);




    void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);

    WEBCORE_EXPORT void didGetAllDatabaseNamesAndVersions(const IDBResourceIdentifier&, Vector<IDBDatabaseNameAndVersion>&&);

    void registerDatabaseConnection(UniqueIDBDatabaseConnection&);
    void unregisterDatabaseConnection(UniqueIDBDatabaseConnection&);
    WEBCORE_EXPORT void connectionToClientClosed();
    bool isClosed() { return m_isClosed; }
    void clearDelegate() { m_delegate = nullptr; }




    m_transactions.remove(transaction.info().identifier());
}

void IDBServer::registerConnection(UniqueIDBDatabaseConnection& connection)
{
    ASSERT(!m_databaseConnections.contains(connection.identifier()));
    m_databaseConnections.set(connection.identifier(), &connection);
}

void IDBServer::unregisterConnection(UniqueIDBDatabaseConnection& connection)
{
    ASSERT(m_databaseConnections.contains(connection.identifier()));
    m_databaseConnections.remove(connection.identifier());

{
    ASSERT(!isMainThread());
    if (m_databaseDirectoryPath.isEmpty())
        return makeUnique<MemoryIDBBackingStore>(identifier);

    ASSERT(!m_sessionID.isEphemeral());
    if (identifier.isTransient())
        return makeUnique<MemoryIDBBackingStore>(identifier);

    return makeUnique<SQLiteIDBBackingStore>(identifier, upgradedDatabaseDirectory(identifier));
}

void IDBServer::openDatabase(const IDBRequestData& requestData)

        m_uniqueIDBDatabaseMap.remove(database->identifier());
}

std::unique_ptr<UniqueIDBDatabase> IDBServer::closeAndTakeUniqueIDBDatabase(UniqueIDBDatabase& database)
{
    LOG(IndexedDB, "IDBServer::closeUniqueIDBDatabase");
    ASSERT(isMainThread());

    auto uniquePointer = m_uniqueIDBDatabaseMap.take(database.identifier());
    ASSERT(uniquePointer);

    return uniquePointer;
}

void IDBServer::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
{
    LOG(IndexedDB, "IDBServer::abortTransaction");

        FileSystem::moveFile(oldOriginPath, newOriginPath);
}

void IDBServer::requestSpace(const ClientOrigin& origin, uint64_t taskSize, CompletionHandler<void(bool)>&& completionHandler) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
{
    ASSERT(!isMainThread());
    ASSERT(m_lock.isHeld());

    result = m_spaceRequester(origin, taskSize);
    m_lock.lock();

    completionHandler(result == StorageQuotaManager::Decision::Grant);
}

uint64_t IDBServer::diskUsage(const String& rootDirectory, const ClientOrigin& origin)

        FileSystem::makeAllDirectories(newVersionDirectory);
}

String IDBServer::upgradedDatabaseDirectory(const WebCore::IDBDatabaseIdentifier& identifier)
{
    String oldOriginDirectory = identifier.databaseDirectoryRelativeToRoot(m_databaseDirectoryPath, "v0");
    String oldDatabaseDirectory = FileSystem::pathByAppendingComponent(oldOriginDirectory, SQLiteIDBBackingStore::encodeDatabaseName(identifier.databaseName()));
    String newOriginDirectory = identifier.databaseDirectoryRelativeToRoot(m_databaseDirectoryPath, "v1");
    String fileNameHash = SQLiteFileSystem::computeHashForFileName(identifier.databaseName());
    String newDatabaseDirectory = FileSystem::pathByAppendingComponent(newOriginDirectory, fileNameHash);
    FileSystem::makeAllDirectories(newDatabaseDirectory);

    if (FileSystem::fileExists(oldDatabaseDirectory)) {
        FileSystem::moveFile(oldDatabaseDirectory, newDatabaseDirectory);
        FileSystem::deleteEmptyDirectory(oldOriginDirectory);
    }

    return newDatabaseDirectory;
}

bool IDBServer::hasDatabaseActivitiesOnMainThread() const
{
    ASSERT(isMainThread());



#include "StorageQuotaManager.h"
#include "UniqueIDBDatabase.h"
#include "UniqueIDBDatabaseConnection.h"
#include "UniqueIDBDatabaseManager.h"
#include <pal/HysteresisActivity.h>
#include <pal/SessionID.h>
#include <wtf/CrossThreadTaskHandler.h>


namespace IDBServer {

class IDBServer : public UniqueIDBDatabaseManager {
    WTF_MAKE_FAST_ALLOCATED;
public:
    using StorageQuotaManagerSpaceRequester = Function<StorageQuotaManager::Decision(const ClientOrigin&, uint64_t spaceRequested)>;
    WEBCORE_EXPORT IDBServer(PAL::SessionID, const String& databaseDirectoryPath, StorageQuotaManagerSpaceRequester&&, Lock&);


    WEBCORE_EXPORT void getAllDatabaseNamesAndVersions(IDBConnectionIdentifier, const IDBResourceIdentifier&, const ClientOrigin&);

    void registerConnection(UniqueIDBDatabaseConnection&) final;
    void unregisterConnection(UniqueIDBDatabaseConnection&) final;
    void registerTransaction(UniqueIDBDatabaseTransaction&) final;
    void unregisterTransaction(UniqueIDBDatabaseTransaction&) final;
    std::unique_ptr<IDBBackingStore> createBackingStore(const IDBDatabaseIdentifier&) final;

    std::unique_ptr<UniqueIDBDatabase> closeAndTakeUniqueIDBDatabase(UniqueIDBDatabase&);

    std::unique_ptr<IDBBackingStore> createBackingStore(const IDBDatabaseIdentifier&);

    WEBCORE_EXPORT HashSet<SecurityOriginData> getOrigins() const;
    WEBCORE_EXPORT void closeAndDeleteDatabasesModifiedSince(WallTime);

    void closeDatabasesForOrigins(const Vector<SecurityOriginData>&, Function<bool(const SecurityOriginData&, const ClientOrigin&)>&&);
    WEBCORE_EXPORT void renameOrigin(const WebCore::SecurityOriginData&, const WebCore::SecurityOriginData&);

    void requestSpace(const ClientOrigin&, uint64_t size, CompletionHandler<void(bool)>&&) final;
    WEBCORE_EXPORT static uint64_t diskUsage(const String& rootDirectory, const ClientOrigin&);

    WEBCORE_EXPORT bool hasDatabaseActivitiesOnMainThread() const;

    UniqueIDBDatabase& getOrCreateUniqueIDBDatabase(const IDBDatabaseIdentifier&);

    void upgradeFilesIfNecessary();
    String upgradedDatabaseDirectory(const WebCore::IDBDatabaseIdentifier&);
    void removeDatabasesModifiedSinceForVersion(WallTime, const String&);
    void removeDatabasesWithOriginsForVersion(const Vector<SecurityOriginData>&, const String&);




// The IndexedDB spec states the maximum value you can get from the key generator is 2^53.
constexpr uint64_t maxGeneratedKeyValue = 0x20000000000000;

MemoryIDBBackingStore::MemoryIDBBackingStore(const IDBDatabaseIdentifier& identifier)
    : m_identifier(identifier)
    , m_sessionID(sessionID)
{
}


        return IDBError { ConstraintError };

    ASSERT(!m_objectStoresByIdentifier.contains(info.identifier()));
    auto objectStore = MemoryObjectStore::create(info);

    m_databaseInfo->addExistingObjectStore(info);




#include "IDBResourceIdentifier.h"
#include "IndexKey.h"
#include "MemoryBackingStoreTransaction.h"
#include <pal/SessionID.h>
#include <wtf/HashMap.h>

namespace WebCore {

class MemoryIDBBackingStore final : public IDBBackingStore {
    WTF_MAKE_FAST_ALLOCATED;
public:
    WEBCORE_EXPORT MemoryIDBBackingStore(const IDBDatabaseIdentifier&);
    WEBCORE_EXPORT ~MemoryIDBBackingStore();

    IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;
    uint64_t databaseVersion() final;

    void unregisterObjectStore(MemoryObjectStore&);

    IDBDatabaseIdentifier m_identifier;
    PAL::SessionID m_sessionID;
    std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;

    HashMap<IDBResourceIdentifier, std::unique_ptr<MemoryBackingStoreTransaction>> m_transactions;



#include <JavaScriptCore/JSCJSValue.h>
#include <JavaScriptCore/JSCJSValueInlines.h>
#include <JavaScriptCore/JSLock.h>
#include <pal/SessionID.h>

namespace WebCore {
using namespace JSC;
namespace IDBServer {

Ref<MemoryObjectStore> MemoryObjectStore::create(const IDBObjectStoreInfo& info)
{
    return adoptRef(*new MemoryObjectStore(info));
}

MemoryObjectStore::MemoryObjectStore(const IDBObjectStoreInfo& info)
    : m_info(info)
{
}



#include <wtf/HashMap.h>
#include <wtf/RefCounted.h>

namespace PAL {
class SessionID;
}

namespace WebCore {

class IDBCursorInfo;


class MemoryObjectStore : public RefCounted<MemoryObjectStore> {
public:
    static Ref<MemoryObjectStore> create(const IDBObjectStoreInfo&);

    ~MemoryObjectStore();


    void renameIndex(MemoryIndex&, const String& newName);

private:
    MemoryObjectStore(const IDBObjectStoreInfo&);

    IDBKeyDataSet::iterator lowestIteratorInRange(const IDBKeyRangeData&, bool reverse) const;




    return TABLE_SCHEMA_PREFIX "_Temp_IndexInfo" INDEX_INFO_TABLE_SCHEMA_SUFFIX;
}

SQLiteIDBBackingStore::SQLiteIDBBackingStore(const IDBDatabaseIdentifier& identifier, const String& databaseDirectory)
    : m_identifier(identifier)
    , m_databaseDirectory(databaseDirectory)
    , m_databaseRootDirectory(databaseRootDirectory)
{
    m_databaseDirectory = fullDatabaseDirectoryWithUpgrade();
}

SQLiteIDBBackingStore::~SQLiteIDBBackingStore()

    return databaseInfo;
}

String SQLiteIDBBackingStore::encodeDatabaseName(const String& databaseName)
{
    ASSERT(!databaseName.isNull());
    if (databaseName.isEmpty())
    if (m_identifier.databaseName().isEmpty())
        return "%00";

    String filename = FileSystem::encodeForFileName(databaseName);
    filename.replace('.', "%2E");

    return filename;
}

String SQLiteIDBBackingStore::decodeDatabaseName(const String& encodedName)
{
    if (encodedName == "%00"_s)
        return { };

    String name = encodedName;
    name.replace("%2E"_s, "."_s);

    return FileSystem::decodeFromFilename(name);
}

String SQLiteIDBBackingStore::fullDatabasePathForDirectory(const String& fullDatabaseDirectory)
{
    return FileSystem::pathByAppendingComponent(fullDatabaseDirectory, "IndexedDB.sqlite3");

    return IDBDatabaseNameAndVersion { databaseName, *databaseVersion };
}

String SQLiteIDBBackingStore::fullDatabaseDirectoryWithUpgrade()
{
    String oldOriginDirectory = m_identifier.databaseDirectoryRelativeToRoot(m_databaseRootDirectory, "v0");
    String oldDatabaseDirectory = FileSystem::pathByAppendingComponent(oldOriginDirectory, filenameForDatabaseName());
    String newOriginDirectory = m_identifier.databaseDirectoryRelativeToRoot(m_databaseRootDirectory, "v1");
    String fileNameHash = SQLiteFileSystem::computeHashForFileName(m_identifier.databaseName());
    String newDatabaseDirectory = FileSystem::pathByAppendingComponent(newOriginDirectory, fileNameHash);
    FileSystem::makeAllDirectories(newDatabaseDirectory);

    if (FileSystem::fileExists(oldDatabaseDirectory)) {
        FileSystem::moveFile(oldDatabaseDirectory, newDatabaseDirectory);
        FileSystem::deleteEmptyDirectory(oldOriginDirectory);
    }

    return newDatabaseDirectory;
}

IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info)
{
    LOG(IndexedDB, "SQLiteIDBBackingStore::getOrEstablishDatabaseInfo - database %s", m_identifier.databaseName().utf8().data());

        return IDBError { };
    }

    String databasePath = fullDatabasePath();
    FileSystem::makeAllDirectories(FileSystem::parentPath(databasePath));
    m_sqliteDB = makeUnique<SQLiteDatabase>();
    if (!m_sqliteDB->open(databasePath)) {
        LOG_ERROR("Failed to open SQLite database at path '%s'", databasePath.utf8().data());
        closeSQLiteDB();
    }


        databaseInfo = createAndPopulateInitialDatabaseInfo();

    if (!databaseInfo) {
        LOG_ERROR("Unable to establish IDB database at path '%s'", databasePath.utf8().data());
        closeSQLiteDB();
        return IDBError { UnknownError, "Unable to establish IDB database file"_s };
    }


    SQLiteFileSystem::deleteDatabaseFile(databasePath);
    SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_databaseDirectory);
    SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_identifier.databaseDirectoryRelativeToRoot(m_databaseRootDirectory));
}

void SQLiteIDBBackingStore::unregisterCursor(SQLiteIDBCursor& cursor)



class SQLiteIDBBackingStore final : public IDBBackingStore {
    WTF_MAKE_FAST_ALLOCATED;
public:
    WEBCORE_EXPORT SQLiteIDBBackingStore(const IDBDatabaseIdentifier&, const String& databaseDirectory);
    WEBCORE_EXPORT ~SQLiteIDBBackingStore() final;
    ~SQLiteIDBBackingStore() final;

    IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;
    uint64_t databaseVersion() final;


    IDBError getBlobRecordsForObjectStoreRecord(int64_t objectStoreRecord, Vector<String>& blobURLs, Vector<String>& blobFilePaths);

    WEBCORE_EXPORT static uint64_t databasesSizeForDirectory(const String& directory);

    String databaseDirectory() const { return m_databaseDirectory; };
    WEBCORE_EXPORT static String fullDatabasePathForDirectory(const String&);
    WEBCORE_EXPORT static String encodeDatabaseName(const String& databaseName);
    WEBCORE_EXPORT static String decodeDatabaseName(const String& encodedDatabaseName);

    WEBCORE_EXPORT static std::optional<IDBDatabaseNameAndVersion> databaseNameAndVersionFromFile(const String&);

private:
    String filenameForDatabaseName() const;
    String fullDatabaseDirectoryWithUpgrade();

    IDBError ensureValidRecordsTable();
    IDBError ensureValidIndexRecordsTable();
    IDBError ensureValidIndexRecordsIndex();


    std::unique_ptr<SQLiteStatement> m_cachedStatements[static_cast<int>(SQL::Invalid)];

    PAL::SessionID m_sessionID;
    IDBDatabaseIdentifier m_identifier;
    std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;
    std::unique_ptr<IDBDatabaseInfo> m_originalDatabaseInfoBeforeVersionChange;

    HashMap<IDBResourceIdentifier, std::unique_ptr<SQLiteIDBTransaction>> m_transactions;
    HashMap<IDBResourceIdentifier, SQLiteIDBCursor*> m_cursors;

    String m_databaseRootDirectory;
    String m_databaseDirectory;
};


Lines 42-47 a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp -94 / +384 lines
42	#include "Logging.h"	42	#include "Logging.h"
43	#include "StorageQuotaManager.h"	43	#include "StorageQuotaManager.h"
44	#include "UniqueIDBDatabaseConnection.h"	44	#include "UniqueIDBDatabaseConnection.h"
		45	#include "UniqueIDBDatabaseManager.h"
45	#include <wtf/Scope.h>	46	#include <wtf/Scope.h>
46		47
47	namespace WebCore {	48	namespace WebCore {
Lines 134-141 static inline uint64_t estimateSize(const IDBObjectStoreInfo& info) a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec2
134	return size;	135	return size;
135	}	136	}
136		137
137	UniqueIDBDatabase::UniqueIDBDatabase(IDBServer& server, const IDBDatabaseIdentifier& identifier)	138	UniqueIDBDatabase::UniqueIDBDatabase(UniqueIDBDatabaseManager& manager, const IDBDatabaseIdentifier& identifier)
138	: m_server(server)	139	: m_manager(manager)
139	, m_identifier(identifier)	140	, m_identifier(identifier)
140	{	141	{
141	ASSERT(!isMainThread());	142	ASSERT(!isMainThread());
Lines 163-168 const IDBDatabaseInfo& UniqueIDBDatabase::info() const a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec3
163	return *m_databaseInfo;	164	return *m_databaseInfo;
164	}	165	}
165		166
		167	UniqueIDBDatabaseManager* UniqueIDBDatabase::manager()
		168	{
		169	return m_manager.get();
		170	}
		171
166	void UniqueIDBDatabase::openDatabaseConnection(IDBConnectionToClient& connection, const IDBRequestData& requestData)	172	void UniqueIDBDatabase::openDatabaseConnection(IDBConnectionToClient& connection, const IDBRequestData& requestData)
167	{	173	{
168	LOG(IndexedDB, "UniqueIDBDatabase::openDatabaseConnection");	174	LOG(IndexedDB, "UniqueIDBDatabase::openDatabaseConnection");
Lines 185-201 void UniqueIDBDatabase::performCurrentOpenOperation() a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec4
185	ASSERT(m_currentOpenDBRequest);	191	ASSERT(m_currentOpenDBRequest);
186	ASSERT(m_currentOpenDBRequest->isOpenRequest());	192	ASSERT(m_currentOpenDBRequest->isOpenRequest());
187		193
		194	// We don't need to create the file so no need to do space check.
		195	if (m_backingStore)
		196	return performCurrentOpenOperationAfterSpaceCheck(true);
		197
		198	if (!m_manager)
		199	return performCurrentOpenOperationAfterSpaceCheck(false);
		200
		201	auto requestIdentifier = m_currentOpenDBRequest->requestData().requestIdentifier();
		202	if (m_openDBRequestsForSpaceCheck.contains(requestIdentifier))
		203	return;
		204
		205	m_openDBRequestsForSpaceCheck.add(requestIdentifier);
		206	m_manager->requestSpace(m_identifier.origin(), defaultWriteOperationCost, [this, weakThis = WeakPtr { *this }, requestIdentifier](bool granted) mutable {
		207	if (!weakThis)
		208	return;
		209
		210	m_openDBRequestsForSpaceCheck.remove(requestIdentifier);
		211	if (m_currentOpenDBRequest->requestData().requestIdentifier() != requestIdentifier)
		212	return;
		213
		214	performCurrentOpenOperationAfterSpaceCheck(granted);
		215	});
		216	}
		217
		218	void UniqueIDBDatabase::performCurrentOpenOperationAfterSpaceCheck(bool isGranted)
		219	{
		220	LOG(IndexedDB, "UniqueIDBDatabase::performCurrentOpenOperationAfterSpaceRequest (%p)", this);
		221
188	IDBError backingStoreOpenError;	222	IDBError backingStoreOpenError;
189	if (!m_backingStore) {	223	if (!m_backingStore) {
190	// Quota check.	224	if (!m_manager)
191	auto decision = m_server.requestSpace(m_identifier.origin(), defaultWriteOperationCost);	225	backingStoreOpenError = IDBError { InvalidStateError };
192	if (decision == StorageQuotaManager::Decision::Deny)	226	else if (!isGranted)
193	backingStoreOpenError = IDBError { QuotaExceededError, quotaErrorMessageName("OpenBackingStore") };	227	backingStoreOpenError = IDBError { QuotaExceededError, quotaErrorMessageName("OpenBackingStore") };
194	else {	228	else {
195	m_backingStore = m_server.createBackingStore(m_identifier);	229	m_backingStore = m_manager->createBackingStore(m_identifier);
196	IDBDatabaseInfo databaseInfo;	230	IDBDatabaseInfo databaseInfo;
197	backingStoreOpenError = m_backingStore->getOrEstablishDatabaseInfo(databaseInfo);	231	backingStoreOpenError = m_backingStore->getOrEstablishDatabaseInfo(databaseInfo);
198	if (backingStoreOpenError.isNull())	232	if (!backingStoreOpenError)
199	m_databaseInfo = makeUnique<IDBDatabaseInfo>(databaseInfo);	233	m_databaseInfo = makeUnique<IDBDatabaseInfo>(databaseInfo);
200	else {	234	else {
201	LOG_ERROR("Failed to get database info '%s'", backingStoreOpenError.message().utf8().data());	235	LOG_ERROR("Failed to get database info '%s'", backingStoreOpenError.message().utf8().data());
Lines 204-210 void UniqueIDBDatabase::performCurrentOpenOperation() a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec5
204	}	238	}
205	}	239	}
206		240
207	if (!backingStoreOpenError.isNull()) {	241	if (backingStoreOpenError) {
208	auto result = IDBResultData::error(m_currentOpenDBRequest->requestData().requestIdentifier(), backingStoreOpenError);	242	auto result = IDBResultData::error(m_currentOpenDBRequest->requestData().requestIdentifier(), backingStoreOpenError);
209	m_currentOpenDBRequest->connection().didOpenDatabase(result);	243	m_currentOpenDBRequest->connection().didOpenDatabase(result);
210	m_currentOpenDBRequest = nullptr;	244	m_currentOpenDBRequest = nullptr;
Lines 294-300 void UniqueIDBDatabase::deleteBackingStore() a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec6
294	ASSERT(!isMainThread());	328	ASSERT(!isMainThread());
295	LOG(IndexedDB, "UniqueIDBDatabase::deleteBackingStore");	329	LOG(IndexedDB, "UniqueIDBDatabase::deleteBackingStore");
296		330
297	auto backingStore = m_backingStore ? std::exchange(m_backingStore, nullptr) : m_server.createBackingStore(m_identifier);	331	auto backingStore = m_backingStore ? std::exchange(m_backingStore, nullptr) : m_manager->createBackingStore(m_identifier);
298	uint64_t deletedVersion = backingStore->databaseVersion();	332	uint64_t deletedVersion = backingStore->databaseVersion();
299	backingStore->deleteBackingStore();	333	backingStore->deleteBackingStore();
300	didDeleteBackingStore(deletedVersion);	334	didDeleteBackingStore(deletedVersion);
Lines 542-561 void UniqueIDBDatabase::addOpenDatabaseConnection(Ref<UniqueIDBDatabaseConnectio a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec7
542	m_openDatabaseConnections.add(adoptRef(connection.leakRef()));	576	m_openDatabaseConnections.add(adoptRef(connection.leakRef()));
543	}	577	}
544		578
545	void UniqueIDBDatabase::createObjectStore(UniqueIDBDatabaseTransaction& transaction, const IDBObjectStoreInfo& info, ErrorCallback callback)	579	void UniqueIDBDatabase::createObjectStore(UniqueIDBDatabaseTransaction& transaction, const IDBObjectStoreInfo& info, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
546	{	580	{
547	ASSERT(!isMainThread());	581	ASSERT(!isMainThread());
548	LOG(IndexedDB, "UniqueIDBDatabase::createObjectStore");	582	LOG(IndexedDB, "UniqueIDBDatabase::createObjectStore");
549		583
550	ASSERT(m_backingStore);	584	if (!spaceCheckResult) {
		585	if (!m_manager)
		586	return callback(IDBError { InvalidStateError });
		587
		588	auto taskSize = defaultWriteOperationCost + estimateSize(info);
		589	m_manager->requestSpace(m_identifier.origin(), taskSize, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, info, callback = WTFMove(callback)](bool granted) mutable {
		590	if (!weakThis \|\| !weakTransaction)
		591	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		592	createObjectStore(*weakTransaction, info, WTFMove(callback), granted);
		593	});
		594	return;
		595	}
551		596
552	// Quota check.	597	if (!spaceCheckResult.value()) {
553	auto taskSize = defaultWriteOperationCost + estimateSize(info);
554	if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {
555	callback(IDBError { QuotaExceededError, quotaErrorMessageName("CreateObjectStore") });	598	callback(IDBError { QuotaExceededError, quotaErrorMessageName("CreateObjectStore") });
556	return;	599	return;
557	}	600	}
558		601
		602	if (!m_backingStore)
		603	return callback(IDBError { InvalidStateError, "Backing store has closed" });
		604
559	auto error = m_backingStore->createObjectStore(transaction.info().identifier(), info);	605	auto error = m_backingStore->createObjectStore(transaction.info().identifier(), info);
560	if (error.isNull())	606	if (error.isNull())
561	m_databaseInfo->addExistingObjectStore(info);	607	m_databaseInfo->addExistingObjectStore(info);
Lines 563-580 void UniqueIDBDatabase::createObjectStore(UniqueIDBDatabaseTransaction& transact a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec8
563	callback(error);	609	callback(error);
564	}	610	}
565		611
566	void UniqueIDBDatabase::deleteObjectStore(UniqueIDBDatabaseTransaction& transaction, const String& objectStoreName, ErrorCallback callback)	612	void UniqueIDBDatabase::deleteObjectStore(UniqueIDBDatabaseTransaction& transaction, const String& objectStoreName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
567	{	613	{
568	ASSERT(!isMainThread());	614	ASSERT(!isMainThread());
569	LOG(IndexedDB, "UniqueIDBDatabase::deleteObjectStore");	615	LOG(IndexedDB, "UniqueIDBDatabase::deleteObjectStore");
570		616
		617	if (!spaceCheckResult) {
		618	if (!m_manager)
		619	return callback(IDBError { InvalidStateError });
		620
		621	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, objectStoreName, callback = WTFMove(callback)](bool granted) mutable {
		622	if (!weakThis \|\| !weakTransaction)
		623	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		624
		625	deleteObjectStore(*weakTransaction, objectStoreName, WTFMove(callback), granted);
		626	});
		627	return;
		628	}
		629
		630	ASSERT(spaceCheckResult.value());
571	auto* info = m_databaseInfo->infoForExistingObjectStore(objectStoreName);	631	auto* info = m_databaseInfo->infoForExistingObjectStore(objectStoreName);
572	if (!info) {	632	if (!info) {
573	callback(IDBError { UnknownError, "Attempt to delete non-existant object store"_s });	633	callback(IDBError { UnknownError, "Attempt to delete non-existant object store"_s });
574	return;	634	return;
575	}	635	}
576		636
577	ASSERT(m_backingStore);	637	if (!m_backingStore)
		638	return callback(IDBError { InvalidStateError, "Backing store is closed" });
		639
578	auto error = m_backingStore->deleteObjectStore(transaction.info().identifier(), info->identifier());	640	auto error = m_backingStore->deleteObjectStore(transaction.info().identifier(), info->identifier());
579	if (error.isNull())	641	if (error.isNull())
580	m_databaseInfo->deleteObjectStore(info->identifier());	642	m_databaseInfo->deleteObjectStore(info->identifier());
Lines 582-595 void UniqueIDBDatabase::deleteObjectStore(UniqueIDBDatabaseTransaction& transact a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec9
582	callback(error);	644	callback(error);
583	}	645	}
584		646
585	void UniqueIDBDatabase::renameObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback callback)	647	void UniqueIDBDatabase::renameObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
586	{	648	{
587	ASSERT(!isMainThread());	649	ASSERT(!isMainThread());
588	LOG(IndexedDB, "UniqueIDBDatabase::renameObjectStore");	650	LOG(IndexedDB, "UniqueIDBDatabase::renameObjectStore");
589		651
590	// Quota check.	652	if (!spaceCheckResult) {
591	auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();	653	if (!m_manager)
592	if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {	654	return callback(IDBError { InvalidStateError });
		655
		656	auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
		657	m_manager->requestSpace(m_identifier.origin(), taskSize, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, objectStoreIdentifier, newName, callback = WTFMove(callback)](bool granted) mutable {
		658	if (!weakThis \|\| !weakTransaction)
		659	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		660
		661	renameObjectStore(*weakTransaction, objectStoreIdentifier, newName, WTFMove(callback), granted);
		662	});
		663	return;
		664	}
		665
		666	if (!spaceCheckResult.value()) {
593	callback(IDBError(QuotaExceededError, quotaErrorMessageName("RenameObjectStore")));	667	callback(IDBError(QuotaExceededError, quotaErrorMessageName("RenameObjectStore")));
594	return;	668	return;
595	}	669	}
Lines 600-606 void UniqueIDBDatabase::renameObjectStore(UniqueIDBDatabaseTransaction& transact a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec10
600	return;	674	return;
601	}	675	}
602		676
603	ASSERT(m_backingStore);	677	if (!m_backingStore)
		678	return callback(IDBError { InvalidStateError, "Backing store is closed" });
		679
604	auto error = m_backingStore->renameObjectStore(transaction.info().identifier(), objectStoreIdentifier, newName);	680	auto error = m_backingStore->renameObjectStore(transaction.info().identifier(), objectStoreIdentifier, newName);
605	if (error.isNull())	681	if (error.isNull())
606	m_databaseInfo->renameObjectStore(objectStoreIdentifier, newName);	682	m_databaseInfo->renameObjectStore(objectStoreIdentifier, newName);
Lines 608-637 void UniqueIDBDatabase::renameObjectStore(UniqueIDBDatabaseTransaction& transact a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec11
608	callback(error);	684	callback(error);
609	}	685	}
610		686
611	void UniqueIDBDatabase::clearObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, ErrorCallback callback)	687	void UniqueIDBDatabase::clearObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
612	{	688	{
613	ASSERT(!isMainThread());	689	ASSERT(!isMainThread());
614	LOG(IndexedDB, "UniqueIDBDatabase::clearObjectStore");	690	LOG(IndexedDB, "UniqueIDBDatabase::clearObjectStore");
615		691
616	ASSERT(m_backingStore);	692	if (!spaceCheckResult) {
617	auto error = m_backingStore->clearObjectStore(transaction.info().identifier(), objectStoreIdentifier);	693	if (!m_manager)
		694	return callback(IDBError { InvalidStateError });
		695
		696	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, objectStoreIdentifier, callback = WTFMove(callback)](bool granted) mutable {
		697	if (!weakThis \|\| !weakTransaction)
		698	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		699
		700	clearObjectStore(*weakTransaction, objectStoreIdentifier, WTFMove(callback), granted);
		701	});
		702	return;
		703	}
		704
		705	ASSERT(spaceCheckResult.value());
		706	if (!m_backingStore)
		707	return callback(IDBError { InvalidStateError, "Backing store is closed" });
618		708
		709	auto error = m_backingStore->clearObjectStore(transaction.info().identifier(), objectStoreIdentifier);
619	callback(error);	710	callback(error);
620	}	711	}
621		712
622	void UniqueIDBDatabase::createIndex(UniqueIDBDatabaseTransaction& transaction, const IDBIndexInfo& info, ErrorCallback callback)	713	void UniqueIDBDatabase::createIndex(UniqueIDBDatabaseTransaction& transaction, const IDBIndexInfo& info, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
623	{	714	{
624	ASSERT(!isMainThread());	715	ASSERT(!isMainThread());
625	LOG(IndexedDB, "UniqueIDBDatabase::createIndex");	716	LOG(IndexedDB, "UniqueIDBDatabase::createIndex");
626		717
627	// Quota check.	718	if (!spaceCheckResult) {
628	auto taskSize = defaultWriteOperationCost + estimateSize(info);	719	if (!m_manager)
629	if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {	720	return callback(IDBError { InvalidStateError });
		721
		722	auto taskSize = defaultWriteOperationCost + estimateSize(info);
		723	m_manager->requestSpace(m_identifier.origin(), taskSize, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, info, callback = WTFMove(callback)](bool granted) mutable {
		724	if (!weakThis \|\| !weakTransaction)
		725	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		726
		727	createIndex(*weakTransaction, info, WTFMove(callback), granted);
		728	});
		729	return;
		730	}
		731
		732	if (!spaceCheckResult.value()) {
630	callback(IDBError { QuotaExceededError, quotaErrorMessageName("CreateIndex") });	733	callback(IDBError { QuotaExceededError, quotaErrorMessageName("CreateIndex") });
631	return;	734	return;
632	}	735	}
633		736
634	ASSERT(m_backingStore);	737	if (!m_backingStore)
		738	return callback(IDBError { InvalidStateError, "Backing store is closed" });
		739
635	auto error = m_backingStore->createIndex(transaction.info().identifier(), info);	740	auto error = m_backingStore->createIndex(transaction.info().identifier(), info);
636	if (error.isNull()) {	741	if (error.isNull()) {
637	ASSERT(m_databaseInfo);	742	ASSERT(m_databaseInfo);
Lines 644-654 void UniqueIDBDatabase::createIndex(UniqueIDBDatabaseTransaction& transaction, c a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec12
644	callback(error);	749	callback(error);
645	}	750	}
646		751
647	void UniqueIDBDatabase::deleteIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback callback)	752	void UniqueIDBDatabase::deleteIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
648	{	753	{
649	ASSERT(!isMainThread());	754	ASSERT(!isMainThread());
650	LOG(IndexedDB, "UniqueIDBDatabase::deleteIndex");	755	LOG(IndexedDB, "UniqueIDBDatabase::deleteIndex");
651		756
		757	if (!spaceCheckResult) {
		758	if (!m_manager)
		759	return callback(IDBError { InvalidStateError });
		760
		761	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, objectStoreIdentifier, indexName, callback = WTFMove(callback)](bool granted) mutable {
		762	if (!weakThis \|\| !weakTransaction)
		763	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		764
		765	deleteIndex(*weakTransaction, objectStoreIdentifier, indexName, WTFMove(callback), granted);
		766	});
		767	return;
		768	}
		769
		770	ASSERT(spaceCheckResult.value());
		771	if (!m_backingStore)
		772	return callback(IDBError { InvalidStateError, "Backing store is closed" });
		773
652	auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);	774	auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
653	if (!objectStoreInfo) {	775	if (!objectStoreInfo) {
654	callback(IDBError { UnknownError, "Attempt to delete index from non-existant object store"_s });	776	callback(IDBError { UnknownError, "Attempt to delete index from non-existant object store"_s });
Lines 660-668 void UniqueIDBDatabase::deleteIndex(UniqueIDBDatabaseTransaction& transaction, u a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec13
660	callback(IDBError { UnknownError, "Attempt to delete non-existant index"_s });	782	callback(IDBError { UnknownError, "Attempt to delete non-existant index"_s });
661	return;	783	return;
662	}	784	}
663	auto indexIdentifier = indexInfo->identifier();
664		785
665	ASSERT(m_backingStore);	786	auto indexIdentifier = indexInfo->identifier();
666	auto error = m_backingStore->deleteIndex(transaction.info().identifier(), objectStoreIdentifier, indexIdentifier);	787	auto error = m_backingStore->deleteIndex(transaction.info().identifier(), objectStoreIdentifier, indexIdentifier);
667	if (error.isNull())	788	if (error.isNull())
668	objectStoreInfo->deleteIndex(indexIdentifier);	789	objectStoreInfo->deleteIndex(indexIdentifier);
Lines 670-687 void UniqueIDBDatabase::deleteIndex(UniqueIDBDatabaseTransaction& transaction, u a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec14
670	callback(error);	791	callback(error);
671	}	792	}
672		793
673	void UniqueIDBDatabase::renameIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback callback)	794	void UniqueIDBDatabase::renameIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
674	{	795	{
675	ASSERT(!isMainThread());	796	ASSERT(!isMainThread());
676	LOG(IndexedDB, "UniqueIDBDatabase::renameIndex");	797	LOG(IndexedDB, "UniqueIDBDatabase::renameIndex");
677		798
678	// Quota check.	799	if (!spaceCheckResult) {
679	auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();	800	if (!m_manager)
680	if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {	801	return callback(IDBError { InvalidStateError });
		802
		803	auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
		804	m_manager->requestSpace(m_identifier.origin(), taskSize, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, objectStoreIdentifier, indexIdentifier, newName, callback = WTFMove(callback)](bool granted) mutable {
		805	if (!weakThis \|\| !weakTransaction)
		806	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		807
		808	renameIndex(*weakTransaction, objectStoreIdentifier, indexIdentifier, newName, WTFMove(callback), granted);
		809	});
		810	return;
		811	}
		812
		813	if (!spaceCheckResult.value()) {
681	callback(IDBError { QuotaExceededError, quotaErrorMessageName("RenameIndex") });	814	callback(IDBError { QuotaExceededError, quotaErrorMessageName("RenameIndex") });
682	return;	815	return;
683	}	816	}
684		817
		818	if (!m_backingStore)
		819	return callback(IDBError { InvalidStateError, "Backing store is closed" });
		820
685	auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);	821	auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
686	if (!objectStoreInfo) {	822	if (!objectStoreInfo) {
687	callback(IDBError { UnknownError, "Attempt to rename index in non-existant object store"_s });	823	callback(IDBError { UnknownError, "Attempt to rename index in non-existant object store"_s });
Lines 694-700 void UniqueIDBDatabase::renameIndex(UniqueIDBDatabaseTransaction& transaction, u a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec15
694	return;	830	return;
695	}	831	}
696		832
697	ASSERT(m_backingStore);
698	auto error = m_backingStore->renameIndex(transaction.info().identifier(), objectStoreIdentifier, indexIdentifier, newName);	833	auto error = m_backingStore->renameIndex(transaction.info().identifier(), objectStoreIdentifier, indexIdentifier, newName);
699	if (error.isNull())	834	if (error.isNull())
700	indexInfo->rename(newName);	835	indexInfo->rename(newName);
Lines 709-725 void UniqueIDBDatabase::putOrAdd(const IDBRequestData& requestData, const IDBKey a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec16
709		844
710	ASSERT(m_databaseInfo);	845	ASSERT(m_databaseInfo);
711		846
712	IDBKeyData usedKey;	847	if (!m_backingStore)
713	IDBError error;	848	return callback(IDBError { InvalidStateError, "Backing store is closed" }, keyData);
714		849
715	ASSERT(m_backingStore);
716	auto objectStoreIdentifier = requestData.objectStoreIdentifier();	850	auto objectStoreIdentifier = requestData.objectStoreIdentifier();
717	auto* objectStoreInfo = m_backingStore->infoForObjectStore(objectStoreIdentifier);	851	auto* objectStoreInfo = m_backingStore->infoForObjectStore(objectStoreIdentifier);
718	if (!objectStoreInfo) {	852	if (!objectStoreInfo)
719	callback(IDBError { InvalidStateError, "Object store cannot be found in the backing store"_s }, usedKey);	853	return callback(IDBError { InvalidStateError, "Object store cannot be found in the backing store"_s }, keyData);
720	return;	854
721	}	855	if (!m_manager)
		856	return callback(IDBError { InvalidStateError }, keyData);
722		857
		858	IDBKeyData usedKey;
		859	IDBError error;
723	bool usedKeyIsGenerated = false;	860	bool usedKeyIsGenerated = false;
724	uint64_t keyNumber;	861	uint64_t keyNumber;
725	auto transactionIdentifier = requestData.transactionIdentifier();	862	auto transactionIdentifier = requestData.transactionIdentifier();
Lines 730-805 void UniqueIDBDatabase::putOrAdd(const IDBRequestData& requestData, const IDBKey a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec17
730		867
731	if (objectStoreInfo->autoIncrement() && !keyData.isValid()) {	868	if (objectStoreInfo->autoIncrement() && !keyData.isValid()) {
732	error = m_backingStore->generateKeyNumber(transactionIdentifier, objectStoreIdentifier, keyNumber);	869	error = m_backingStore->generateKeyNumber(transactionIdentifier, objectStoreIdentifier, keyNumber);
733	if (!error.isNull()) {	870	if (!error.isNull())
734	callback(error, usedKey);	871	return callback(error, usedKey);
735	return;	872
736	}
737	usedKey.setNumberValue(keyNumber);	873	usedKey.setNumberValue(keyNumber);
738	usedKeyIsGenerated = true;	874	usedKeyIsGenerated = true;
739	} else	875	} else
740	usedKey = keyData;	876	usedKey = keyData;
741		877
742	// Generate index keys up front for more accurate quota check.
743	IndexIDToIndexKeyMap indexKeys;
744	callOnIDBSerializationThreadAndWait([objectStoreInfo = objectStoreInfo->isolatedCopy(), key = usedKey.isolatedCopy(), value = value.isolatedCopy(), &indexKeys](auto& globalObject) {
745	indexKeys = generateIndexKeyMapForValue(globalObject, objectStoreInfo, key, value);
746	});
747
748	if (overwriteMode == IndexedDB::ObjectStoreOverwriteMode::NoOverwrite) {	878	if (overwriteMode == IndexedDB::ObjectStoreOverwriteMode::NoOverwrite) {
749	bool keyExists;	879	bool keyExists;
750	error = m_backingStore->keyExistsInObjectStore(transactionIdentifier, objectStoreIdentifier, usedKey, keyExists);	880	error = m_backingStore->keyExistsInObjectStore(transactionIdentifier, objectStoreIdentifier, usedKey, keyExists);
751	if (error.isNull() && keyExists)	881	if (!error && keyExists)
752	error = IDBError { ConstraintError, "Key already exists in the object store"_s };	882	error = IDBError { ConstraintError, "Key already exists in the object store"_s };
753		883
754	if (!error.isNull()) {	884	if (!!error)
755	callback(error, usedKey);	885	return callback(error, usedKey);
756	return;
757	}
758	}	886	}
759		887
760	// Quota check.	888	// Generate index keys up front for more accurate quota check.
		889	IndexIDToIndexKeyMap indexKeys;
		890	callOnIDBSerializationThreadAndWait([objectStoreInfo = objectStoreInfo->isolatedCopy(), key = usedKey.isolatedCopy(), value = value.isolatedCopy(), &indexKeys](auto& globalObject) {
		891	indexKeys = generateIndexKeyMapForValue(globalObject, objectStoreInfo, key, value);
		892	});
		893
		894	generatedKeyResetter.release();
761	auto keySize = estimateSize(usedKey);	895	auto keySize = estimateSize(usedKey);
762	auto valueSize = estimateSize(value);	896	auto valueSize = estimateSize(value);
763	auto indexSize = estimateSize(*objectStoreInfo, indexKeys, keySize);	897	auto indexSize = estimateSize(*objectStoreInfo, indexKeys, keySize);
764	auto taskSize = defaultWriteOperationCost + keySize + valueSize + indexSize;	898	auto taskSize = defaultWriteOperationCost + keySize + valueSize + indexSize;
765		899
766	LOG(IndexedDB, "UniqueIDBDatabase::putOrAdd quota check with task size: %" PRIu64 " key size: %" PRIu64 " value size: %" PRIu64 " index size: %" PRIu64, taskSize, keySize, valueSize, indexSize);	900	LOG(IndexedDB, "UniqueIDBDatabase::putOrAdd quota check with task size: %" PRIu64 " key size: %" PRIu64 " value size: %" PRIu64 " index size: %" PRIu64, taskSize, keySize, valueSize, indexSize);
		901	m_manager->requestSpace(m_identifier.origin(), taskSize, [this, weakThis = WeakPtr { this }, requestData, usedKey, value, overwriteMode, callback = WTFMove(callback), usedKeyIsGenerated, indexKeys, objectStoreInfo = objectStoreInfo](bool granted) mutable {
		902	if (!weakThis)
		903	return callback(IDBError { InvalidStateError, "Database is closed" }, usedKey);
767		904
768	if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {	905	putOrAddAfterSpaceCheck(requestData, usedKey, value, overwriteMode, WTFMove(callback), usedKeyIsGenerated, indexKeys, objectStoreInfo, granted);
769	callback(IDBError { QuotaExceededError, quotaErrorMessageName("PutOrAdd") }, usedKey);	906	});
770	return;	907	}
771	}	908
		909	void UniqueIDBDatabase::putOrAddAfterSpaceCheck(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode, KeyDataCallback callback, bool isKeyGenerated, const IndexIDToIndexKeyMap& indexKeys, const IDBObjectStoreInfo& objectStoreInfo, SpaceCheckResult spaceCheckResult)
		910	{
		911	ASSERT(!isMainThread());
		912	ASSERT(m_databaseInfo);
		913
		914	if (!m_backingStore)
		915	return callback(IDBError { InvalidStateError, "Backing store is closed" }, keyData);
		916
		917	uint64_t keyNumber = isKeyGenerated ? keyData.number() : 0;
		918	auto objectStoreIdentifier = objectStoreInfo.identifier();
		919	auto transactionIdentifier = requestData.transactionIdentifier();
		920	auto generatedKeyResetter = makeScopeExit([this, transactionIdentifier, objectStoreIdentifier, &keyNumber, &isKeyGenerated]() {
		921	if (isKeyGenerated)
		922	m_backingStore->revertGeneratedKeyNumber(transactionIdentifier, objectStoreIdentifier, keyNumber);
		923	});
772		924
		925	if (!spaceCheckResult \|\| !spaceCheckResult.value())
		926	return callback(IDBError { QuotaExceededError, quotaErrorMessageName("PutOrAdd") }, keyData);
773	// If a record already exists in store, then remove the record from store using the steps for deleting records from an object store.	927	// If a record already exists in store, then remove the record from store using the steps for deleting records from an object store.
774	// This is important because formally deleting it from from the object store also removes it from the appropriate indexes.	928	// This is important because formally deleting it from the object store also removes it from the appropriate indexes.
775	error = m_backingStore->deleteRange(transactionIdentifier, objectStoreIdentifier, usedKey);	929	IDBError error = m_backingStore->deleteRange(transactionIdentifier, objectStoreIdentifier, keyData);
776	if (!error.isNull()) {	930	if (!error.isNull())
777	callback(error, usedKey);	931	return callback(error, keyData);
778	return;
779	}
780		932
781	error = m_backingStore->addRecord(transactionIdentifier, *objectStoreInfo, usedKey, indexKeys, value);	933	error = m_backingStore->addRecord(transactionIdentifier, objectStoreInfo, keyData, indexKeys, value);
782	if (!error.isNull()) {	934	if (!error.isNull())
783	callback(error, usedKey);	935	return callback(error, keyData);
784	return;
785	}
786		936
787	if (overwriteMode != IndexedDB::ObjectStoreOverwriteMode::OverwriteForCursor && objectStoreInfo->autoIncrement() && keyData.type() == IndexedDB::KeyType::Number)	937	if (overwriteMode != IndexedDB::ObjectStoreOverwriteMode::OverwriteForCursor && objectStoreInfo.autoIncrement() && keyData.type() == IndexedDB::KeyType::Number)
788	error = m_backingStore->maybeUpdateKeyGeneratorNumber(transactionIdentifier, objectStoreIdentifier, keyData.number());	938	error = m_backingStore->maybeUpdateKeyGeneratorNumber(transactionIdentifier, objectStoreIdentifier, keyData.number());
789		939
790	generatedKeyResetter.release();	940	generatedKeyResetter.release();
791	callback(error, usedKey);	941	callback(error, keyData);
792	}	942	}
793		943
794	void UniqueIDBDatabase::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback)	944	void UniqueIDBDatabase::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback, SpaceCheckResult spaceCheckResult)
795	{	945	{
796	ASSERT(!isMainThread());	946	ASSERT(!isMainThread());
797	LOG(IndexedDB, "UniqueIDBDatabase::getRecord");	947	LOG(IndexedDB, "UniqueIDBDatabase::getRecord");
798		948
		949	if (!spaceCheckResult) {
		950	if (!m_manager)
		951	return callback(IDBError { InvalidStateError }, IDBGetResult { });
		952
		953	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, requestData, getRecordData, callback = WTFMove(callback)](bool granted) mutable {
		954	if (!weakThis)
		955	return callback(IDBError { InvalidStateError, "Database is closed" }, IDBGetResult { });
		956
		957	getRecord(requestData, getRecordData, WTFMove(callback), granted);
		958	});
		959	return;
		960	}
		961
		962	ASSERT(spaceCheckResult.value());
		963	if (!m_backingStore)
		964	return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetResult { });
		965
799	IDBGetResult result;	966	IDBGetResult result;
800	IDBError error;	967	IDBError error;
801		968
802	ASSERT(m_backingStore);
803	if (uint64_t indexIdentifier = requestData.indexIdentifier())	969	if (uint64_t indexIdentifier = requestData.indexIdentifier())
804	error = m_backingStore->getIndexRecord(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), indexIdentifier, requestData.indexRecordType(), getRecordData.keyRangeData, result);	970	error = m_backingStore->getIndexRecord(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), indexIdentifier, requestData.indexRecordType(), getRecordData.keyRangeData, result);
805	else	971	else
Lines 808-854 void UniqueIDBDatabase::getRecord(const IDBRequestData& requestData, const IDBGe a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec18
808	callback(error, result);	974	callback(error, result);
809	}	975	}
810		976
811	void UniqueIDBDatabase::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback)	977	void UniqueIDBDatabase::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback, SpaceCheckResult spaceCheckResult)
812	{	978	{
813	ASSERT(!isMainThread());	979	ASSERT(!isMainThread());
814	LOG(IndexedDB, "UniqueIDBDatabase::getAllRecords");	980	LOG(IndexedDB, "UniqueIDBDatabase::getAllRecords");
815		981
816	ASSERT(m_backingStore);	982	if (!spaceCheckResult) {
		983	if (!m_manager)
		984	return callback(IDBError { InvalidStateError }, IDBGetAllResult { });
		985
		986	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, requestData, getAllRecordsData, callback = WTFMove(callback)](bool granted) mutable {
		987	if (!weakThis)
		988	return callback(IDBError { InvalidStateError, "Database is closed" }, IDBGetAllResult { });
		989
		990	getAllRecords(requestData, getAllRecordsData, WTFMove(callback), granted);
		991	});
		992	return;
		993	}
		994
		995	ASSERT(spaceCheckResult.value());
		996	if (!m_backingStore)
		997	return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetAllResult { });
		998
817	IDBGetAllResult result;	999	IDBGetAllResult result;
818	auto error = m_backingStore->getAllRecords(requestData.transactionIdentifier(), getAllRecordsData, result);	1000	auto error = m_backingStore->getAllRecords(requestData.transactionIdentifier(), getAllRecordsData, result);
819		1001
820	callback(error, result);	1002	callback(error, result);
821	}	1003	}
822		1004
823	void UniqueIDBDatabase::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback)	1005	void UniqueIDBDatabase::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback, SpaceCheckResult spaceCheckResult)
824	{	1006	{
825	ASSERT(!isMainThread());	1007	ASSERT(!isMainThread());
826	LOG(IndexedDB, "UniqueIDBDatabase::getCount");	1008	LOG(IndexedDB, "UniqueIDBDatabase::getCount");
827		1009
828	ASSERT(m_backingStore);	1010	if (!spaceCheckResult) {
		1011	if (!m_manager)
		1012	return callback(IDBError { InvalidStateError }, 0);
		1013
		1014	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, requestData, range, callback = WTFMove(callback)](bool granted) mutable {
		1015	if (!weakThis)
		1016	return callback(IDBError { InvalidStateError, "Database is closed" }, 0);
		1017
		1018	getCount(requestData, range, WTFMove(callback), granted);
		1019	});
		1020	return;
		1021	}
		1022
		1023	ASSERT(spaceCheckResult.value());
		1024	if (!m_backingStore)
		1025	return callback(IDBError { InvalidStateError, "Backing store is closed" }, 0);
		1026
829	uint64_t count = 0;	1027	uint64_t count = 0;
830	auto error = m_backingStore->getCount(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), requestData.indexIdentifier(), range, count);	1028	auto error = m_backingStore->getCount(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), requestData.indexIdentifier(), range, count);
831		1029
832	callback(error, count);	1030	callback(error, count);
833	}	1031	}
834		1032
835	void UniqueIDBDatabase::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback)	1033	void UniqueIDBDatabase::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
836	{	1034	{
837	ASSERT(!isMainThread());	1035	ASSERT(!isMainThread());
838	LOG(IndexedDB, "UniqueIDBDatabase::deleteRecord");	1036	LOG(IndexedDB, "UniqueIDBDatabase::deleteRecord");
839		1037
840	ASSERT(m_backingStore);	1038	if (!spaceCheckResult) {
		1039	if (!m_manager)
		1040	return callback(IDBError { InvalidStateError });
		1041
		1042	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, requestData, keyRangeData, callback = WTFMove(callback)](bool granted) mutable {
		1043	if (!weakThis)
		1044	return callback(IDBError { InvalidStateError, "Database is closed" });
		1045
		1046	deleteRecord(requestData, keyRangeData, WTFMove(callback), granted);
		1047	});
		1048	return;
		1049	}
		1050
		1051	ASSERT(spaceCheckResult.value());
		1052	if (!m_backingStore)
		1053	return callback(IDBError { InvalidStateError, "Backing store is closed" });
		1054
841	auto error = m_backingStore->deleteRange(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), keyRangeData);	1055	auto error = m_backingStore->deleteRange(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), keyRangeData);
842		1056
843	callback(error);	1057	callback(error);
844	}	1058	}
845		1059
846	void UniqueIDBDatabase::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback)	1060	void UniqueIDBDatabase::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback, SpaceCheckResult spaceCheckResult)
847	{	1061	{
848	ASSERT(!isMainThread());	1062	ASSERT(!isMainThread());
849	LOG(IndexedDB, "UniqueIDBDatabase::openCursor");	1063	LOG(IndexedDB, "UniqueIDBDatabase::openCursor");
850		1064
851	ASSERT(m_backingStore);	1065	if (!spaceCheckResult) {
		1066	if (!m_manager)
		1067	return callback(IDBError { InvalidStateError }, IDBGetResult { });
		1068
		1069	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, requestData, info, callback = WTFMove(callback)](bool granted) mutable {
		1070	if (!weakThis)
		1071	return callback(IDBError { InvalidStateError, "Database or transaction is closed" }, IDBGetResult { });
		1072
		1073	openCursor(requestData, info, WTFMove(callback), granted);
		1074	});
		1075	return;
		1076	}
		1077
		1078	ASSERT(spaceCheckResult.value());
		1079	if (!m_backingStore)
		1080	return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetResult { });
852		1081
853	IDBGetResult result;	1082	IDBGetResult result;
854	auto error = m_backingStore->openCursor(requestData.transactionIdentifier(), info, result);	1083	auto error = m_backingStore->openCursor(requestData.transactionIdentifier(), info, result);
Lines 856-867 void UniqueIDBDatabase::openCursor(const IDBRequestData& requestData, const IDBC a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec19
856	callback(error, result);	1085	callback(error, result);
857	}	1086	}
858		1087
859	void UniqueIDBDatabase::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback)	1088	void UniqueIDBDatabase::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback, SpaceCheckResult spaceCheckResult)
860	{	1089	{
861	ASSERT(!isMainThread());	1090	ASSERT(!isMainThread());
862	LOG(IndexedDB, "UniqueIDBDatabase::iterateCursor");	1091	LOG(IndexedDB, "UniqueIDBDatabase::iterateCursor");
863		1092
864	ASSERT(m_backingStore);	1093	if (!spaceCheckResult) {
		1094	if (!m_manager)
		1095	return callback(IDBError { InvalidStateError }, IDBGetResult { });
		1096
		1097	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, requestData, data, callback = WTFMove(callback)](bool granted) mutable {
		1098	if (!weakThis)
		1099	return callback(IDBError { InvalidStateError, "Database or transaction is closed" }, IDBGetResult { });
		1100
		1101	iterateCursor(requestData, data, WTFMove(callback), granted);
		1102	});
		1103	return;
		1104	}
		1105
		1106	ASSERT(spaceCheckResult.value());
		1107	if (!m_backingStore)
		1108	return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetResult { });
865		1109
866	IDBGetResult result;	1110	IDBGetResult result;
867	auto transactionIdentifier = requestData.transactionIdentifier();	1111	auto transactionIdentifier = requestData.transactionIdentifier();
Lines 871-883 void UniqueIDBDatabase::iterateCursor(const IDBRequestData& requestData, const I a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec20
871	callback(error, result);	1115	callback(error, result);
872	}	1116	}
873		1117
874	void UniqueIDBDatabase::commitTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)	1118	void UniqueIDBDatabase::commitTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
875	{	1119	{
876	ASSERT(!isMainThread());	1120	ASSERT(!isMainThread());
877	LOG(IndexedDB, "UniqueIDBDatabase::commitTransaction - %s", transaction.info().identifier().loggingString().utf8().data());	1121	LOG(IndexedDB, "UniqueIDBDatabase::commitTransaction - %s", transaction.info().identifier().loggingString().utf8().data());
878		1122
		1123	if (!spaceCheckResult) {
		1124	if (!m_manager)
		1125	return callback(IDBError { InvalidStateError });
		1126
		1127	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, callback = WTFMove(callback)](bool granted) mutable {
		1128	if (!weakThis \|\| !weakTransaction)
		1129	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		1130
		1131	commitTransaction(*weakTransaction, WTFMove(callback), granted);
		1132	});
		1133	return;
		1134	}
		1135
		1136	ASSERT(spaceCheckResult.value());
879	ASSERT(transaction.databaseConnection().database() == this);	1137	ASSERT(transaction.databaseConnection().database() == this);
880	ASSERT(m_backingStore);	1138
		1139	if (!m_backingStore)
		1140	return callback(IDBError { InvalidStateError, "Backing store is closed" });
		1141
881	auto takenTransaction = m_inProgressTransactions.take(transaction.info().identifier());	1142	auto takenTransaction = m_inProgressTransactions.take(transaction.info().identifier());
882	if (!takenTransaction) {	1143	if (!takenTransaction) {
883	if (!m_openDatabaseConnections.contains(&transaction.databaseConnection()))	1144	if (!m_openDatabaseConnections.contains(&transaction.databaseConnection()))
Lines 893-903 void UniqueIDBDatabase::commitTransaction(UniqueIDBDatabaseTransaction& transact a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec21
893	transactionCompleted(WTFMove(takenTransaction));	1154	transactionCompleted(WTFMove(takenTransaction));
894	}	1155	}
895		1156
896	void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)	1157	void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
897	{	1158	{
898	ASSERT(!isMainThread());	1159	ASSERT(!isMainThread());
899	LOG(IndexedDB, "UniqueIDBDatabase::abortTransaction - %s", transaction.info().identifier().loggingString().utf8().data());	1160	LOG(IndexedDB, "UniqueIDBDatabase::abortTransaction - %s", transaction.info().identifier().loggingString().utf8().data());
900		1161
		1162	if (!spaceCheckResult) {
		1163	if (!m_manager)
		1164	return callback(IDBError { InvalidStateError });
		1165
		1166	m_manager->requestSpace(m_identifier.origin(), 0, [this, weakThis = WeakPtr { *this }, weakTransaction = WeakPtr { transaction }, callback = WTFMove(callback)](bool granted) mutable {
		1167	if (!weakThis \|\| !weakTransaction)
		1168	return callback(IDBError { InvalidStateError, "Database or transaction is closed" });
		1169
		1170	abortTransaction(*weakTransaction, WTFMove(callback), granted);
		1171	});
		1172	return;
		1173	}
		1174
		1175	ASSERT(spaceCheckResult.value());
901	ASSERT(transaction.databaseConnection().database() == this);	1176	ASSERT(transaction.databaseConnection().database() == this);
902		1177
903	auto takenTransaction = m_inProgressTransactions.take(transaction.info().identifier());	1178	auto takenTransaction = m_inProgressTransactions.take(transaction.info().identifier());
Lines 925-931 void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transacti a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec22
925	m_databaseInfo = makeUnique<IDBDatabaseInfo>(*m_versionChangeTransaction->originalDatabaseInfo());	1200	m_databaseInfo = makeUnique<IDBDatabaseInfo>(*m_versionChangeTransaction->originalDatabaseInfo());
926	}	1201	}
927		1202
928	auto error = m_backingStore->abortTransaction(transactionIdentifier);	1203	IDBError error;
		1204	if (!m_backingStore)
		1205	error = IDBError { InvalidStateError, "Backing store is closed" };
		1206	else
		1207	error = m_backingStore->abortTransaction(transactionIdentifier);
929		1208
930	callback(error);	1209	callback(error);
931	transactionCompleted(WTFMove(takenTransaction));	1210	transactionCompleted(WTFMove(takenTransaction));
Lines 1204-1209 void UniqueIDBDatabase::abortActiveTransactions() a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec23
1204	}	1483	}
1205	}	1484	}
1206		1485
		1486	void UniqueIDBDatabase::abortInProgressTransactions()
		1487	{
		1488	for (auto& identifier : copyToVector(m_inProgressTransactions.keys()))
		1489	m_inProgressTransactions.get(identifier)->abortWithoutCallback();
		1490	}
		1491
1207	void UniqueIDBDatabase::close()	1492	void UniqueIDBDatabase::close()
1208	{	1493	{
1209	LOG(IndexedDB, "UniqueIDBDatabase::close");	1494	LOG(IndexedDB, "UniqueIDBDatabase::close");
Lines 1213-1219 void UniqueIDBDatabase::close() a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec24
1213	m_backingStore = nullptr;	1498	m_backingStore = nullptr;
1214	}	1499	}
1215	}	1500	}
1216		1501
1217	bool UniqueIDBDatabase::tryClose()	1502	bool UniqueIDBDatabase::tryClose()
1218	{	1503	{
1219	if (m_backingStore && m_backingStore->isEphemeral())	1504	if (m_backingStore && m_backingStore->isEphemeral())
Lines 1225-1230 bool UniqueIDBDatabase::tryClose() a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp_sec25
1225	close();	1510	close();
1226	return true;	1511	return true;
1227	}	1512	}
		1513
		1514	bool UniqueIDBDatabase::hasDataInMemory() const
		1515	{
		1516	return m_backingStore ? m_backingStore->isEphemeral() : false;
		1517	}
1228		1518
1229	RefPtr<ServerOpenDBRequest> UniqueIDBDatabase::takeNextRunnableRequest(RequestType requestType)	1519	RefPtr<ServerOpenDBRequest> UniqueIDBDatabase::takeNextRunnableRequest(RequestType requestType)
1230	{	1520	{



namespace IDBServer {

class IDBConnectionToClient;
class IDBServer;
class UniqueIDBDatabaseConnection;
class UniqueIDBDatabaseManager;

typedef Function<void(const IDBError&)> ErrorCallback;
typedef Function<void(const IDBError&, const IDBKeyData&)> KeyDataCallback;

class UniqueIDBDatabase : public CanMakeWeakPtr<UniqueIDBDatabase> {
    WTF_MAKE_FAST_ALLOCATED;
public:
    WEBCORE_EXPORT UniqueIDBDatabase(UniqueIDBDatabaseManager&, const IDBDatabaseIdentifier&);
    UniqueIDBDatabase(UniqueIDBDatabase&) = delete;
    WEBCORE_EXPORT ~UniqueIDBDatabase();

    WEBCORE_EXPORT void openDatabaseConnection(IDBConnectionToClient&, const IDBRequestData&);

    const IDBDatabaseInfo& info() const;
    UniqueIDBDatabaseManager* manager();
    const IDBDatabaseIdentifier& identifier() const { return m_identifier; }

    using SpaceCheckResult = std::optional<bool>;
    void createObjectStore(UniqueIDBDatabaseTransaction&, const IDBObjectStoreInfo&, ErrorCallback, SpaceCheckResult = std::nullopt);
    void deleteObjectStore(UniqueIDBDatabaseTransaction&, const String& objectStoreName, ErrorCallback, SpaceCheckResult = std::nullopt);
    void renameObjectStore(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback, SpaceCheckResult = std::nullopt);
    void clearObjectStore(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, ErrorCallback, SpaceCheckResult = std::nullopt);
    void createIndex(UniqueIDBDatabaseTransaction&, const IDBIndexInfo&, ErrorCallback, SpaceCheckResult = std::nullopt);
    void deleteIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback, SpaceCheckResult = std::nullopt);
    void renameIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback, SpaceCheckResult = std::nullopt);
    void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback);
    void putOrAddAfterSpaceCheck(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback, bool isKeyGenerated, const IndexIDToIndexKeyMap&, const IDBObjectStoreInfo&, SpaceCheckResult);
    void getRecord(const IDBRequestData&, const IDBGetRecordData&, GetResultCallback, SpaceCheckResult = std::nullopt);
    void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&, GetAllResultsCallback, SpaceCheckResult = std::nullopt);
    void getCount(const IDBRequestData&, const IDBKeyRangeData&, CountCallback, SpaceCheckResult = std::nullopt);
    void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&, ErrorCallback, SpaceCheckResult = std::nullopt);
    void openCursor(const IDBRequestData&, const IDBCursorInfo&, GetResultCallback, SpaceCheckResult = std::nullopt);
    void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback, SpaceCheckResult = std::nullopt);
    void commitTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback, SpaceCheckResult = std::nullopt);
    void abortTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback, SpaceCheckResult = std::nullopt);

    void didFinishHandlingVersionChange(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& transactionIdentifier);
    void connectionClosedFromClient(UniqueIDBDatabaseConnection&);
    void didFireVersionChangeEvent(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& requestIdentifier, IndexedDB::ConnectionClosedOnBehalfOfServer);
    WEBCORE_EXPORT void openDBRequestCancelled(const IDBResourceIdentifier& requestIdentifier);

    void enqueueTransaction(Ref<UniqueIDBDatabaseTransaction>&&);

    WEBCORE_EXPORT void handleDelete(IDBConnectionToClient&, const IDBRequestData&);
    WEBCORE_EXPORT void immediateClose();

    bool hasActiveTransactions() const;
    void abortActiveTransactions();
    WEBCORE_EXPORT void abortInProgressTransactions();
    WEBCORE_EXPORT bool tryClose();

    WEBCORE_EXPORT String filePath() const;
    WEBCORE_EXPORT std::optional<IDBDatabaseNameAndVersion> nameAndVersion() const;
    WEBCORE_EXPORT bool hasDataInMemory() const;

private:
    void handleDatabaseOperations();
    void handleCurrentOperation();
    void performCurrentOpenOperation();
    void performCurrentOpenOperationAfterSpaceCheck(bool isGranted);
    void performCurrentDeleteOperation();
    enum class RequestType { Delete, Any };
    RefPtr<ServerOpenDBRequest> takeNextRunnableRequest(RequestType = RequestType::Any);


    void clearTransactionsOnConnection(UniqueIDBDatabaseConnection&);

    IDBServer* m_server;
    WeakPtr<UniqueIDBDatabaseManager> m_manager;
    IDBDatabaseIdentifier m_identifier;

    ListHashSet<RefPtr<ServerOpenDBRequest>> m_pendingOpenDBRequests;
    RefPtr<ServerOpenDBRequest> m_currentOpenDBRequest;
    HashSet<IDBResourceIdentifier> m_openDBRequestsForSpaceCheck;

    ListHashSet<RefPtr<UniqueIDBDatabaseConnection>> m_openDatabaseConnections;


Lines 31-36 a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp -3 / +13 lines
31	#include "Logging.h"	31	#include "Logging.h"
32	#include "ServerOpenDBRequest.h"	32	#include "ServerOpenDBRequest.h"
33	#include "UniqueIDBDatabase.h"	33	#include "UniqueIDBDatabase.h"
		34	#include "UniqueIDBDatabaseManager.h"
34		35
35	namespace WebCore {	36	namespace WebCore {
36	namespace IDBServer {	37	namespace IDBServer {
Lines 42-52 Ref<UniqueIDBDatabaseConnection> UniqueIDBDatabaseConnection::create(UniqueIDBDa a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp_sec2
42		43
43	UniqueIDBDatabaseConnection::UniqueIDBDatabaseConnection(UniqueIDBDatabase& database, ServerOpenDBRequest& request)	44	UniqueIDBDatabaseConnection::UniqueIDBDatabaseConnection(UniqueIDBDatabase& database, ServerOpenDBRequest& request)
44	: m_database(database)	45	: m_database(database)
45	, m_server(database.server())	46	, m_manager(database.manager())
46	, m_connectionToClient(request.connection())	47	, m_connectionToClient(request.connection())
47	, m_openRequestIdentifier(request.requestData().requestIdentifier())	48	, m_openRequestIdentifier(request.requestData().requestIdentifier())
48	{	49	{
49	m_server.registerDatabaseConnection(*this);	50	if (auto* manager = database.manager()) {
		51	m_manager = WeakPtr { *manager };
		52	m_manager->registerConnection(*this);
		53	}
50	m_connectionToClient->registerDatabaseConnection(*this);	54	m_connectionToClient->registerDatabaseConnection(*this);
51	}	55	}
52		56
Lines 54-63 UniqueIDBDatabaseConnection::~UniqueIDBDatabaseConnection() a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp_sec3
54	{	58	{
55	ASSERT(m_transactionMap.isEmpty());	59	ASSERT(m_transactionMap.isEmpty());
56		60
57	m_server.unregisterDatabaseConnection(*this);	61	if (m_manager)
		62	m_manager->unregisterConnection(*this);
58	m_connectionToClient->unregisterDatabaseConnection(*this);	63	m_connectionToClient->unregisterDatabaseConnection(*this);
59	}	64	}
60		65
		66	UniqueIDBDatabaseManager* UniqueIDBDatabaseConnection::manager()
		67	{
		68	return m_manager.get();
		69	}
		70
61	bool UniqueIDBDatabaseConnection::hasNonFinishedTransactions() const	71	bool UniqueIDBDatabaseConnection::hasNonFinishedTransactions() const
62	{	72	{
63	return !m_transactionMap.isEmpty();	73	return !m_transactionMap.isEmpty();




#pragma once

#include "IDBServer.h"
#include "UniqueIDBDatabase.h"
#include <wtf/HashMap.h>
#include <wtf/Identified.h>


class IDBError;
class IDBResultData;
class UniqueIDBDatabaseManager;

namespace IDBServer {



    const IDBResourceIdentifier& openRequestIdentifier() { return m_openRequestIdentifier; }
    UniqueIDBDatabase* database() { return m_database.get(); }
    UniqueIDBDatabaseManager* manager();
    IDBConnectionToClient& connectionToClient() { return m_connectionToClient; }

    WEBCORE_EXPORT void connectionPendingCloseFromClient();
    WEBCORE_EXPORT void connectionClosedFromClient();

    bool closePending() const { return m_closePending; }


    void fireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion);
    UniqueIDBDatabaseTransaction& createVersionChangeTransaction(uint64_t newVersion);

    WEBCORE_EXPORT void establishTransaction(const IDBTransactionInfo&);
    void didAbortTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);
    void didCommitTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);
    void didCreateObjectStore(const IDBResultData&);

    void didCreateIndex(const IDBResultData&);
    void didDeleteIndex(const IDBResultData&);
    void didRenameIndex(const IDBResultData&);
    WEBCORE_EXPORT void didFireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, IndexedDB::ConnectionClosedOnBehalfOfServer);
    WEBCORE_EXPORT void didFinishHandlingVersionChange(const IDBResourceIdentifier& transactionIdentifier);

    void abortTransactionWithoutCallback(UniqueIDBDatabaseTransaction&);


    UniqueIDBDatabaseConnection(UniqueIDBDatabase&, ServerOpenDBRequest&);

    WeakPtr<UniqueIDBDatabase> m_database;
    WeakPtr<UniqueIDBDatabaseManager> m_manager;
    Ref<IDBConnectionToClient> m_connectionToClient;
    IDBResourceIdentifier m_openRequestIdentifier;




/*
 * 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 "IDBDatabaseIdentifier.h"

namespace WebCore {

struct ClientOrigin;

namespace IDBServer {

class IDBBackingStore;
class UniqueIDBDatabaseConnection;
class UniqueIDBDatabaseTransaction;

class UniqueIDBDatabaseManager : public CanMakeWeakPtr<UniqueIDBDatabaseManager> {
    WTF_MAKE_FAST_ALLOCATED;
public:
    virtual ~UniqueIDBDatabaseManager() { }
    virtual void registerConnection(UniqueIDBDatabaseConnection&) = 0;
    virtual void unregisterConnection(UniqueIDBDatabaseConnection&) = 0;
    virtual void registerTransaction(UniqueIDBDatabaseTransaction&) = 0;
    virtual void unregisterTransaction(UniqueIDBDatabaseTransaction&) = 0;
    virtual std::unique_ptr<IDBBackingStore> createBackingStore(const IDBDatabaseIdentifier&) = 0;
    virtual void requestSpace(const ClientOrigin&, uint64_t size, CompletionHandler<void(bool)>&&) = 0;
};

} // namespace IDBServer

} // namespace WebCore




#include "IDBIterateCursorData.h"
#include "IDBResultData.h"
#include "IDBServer.h"
#include "Logging.h"
#include "UniqueIDBDatabase.h"


    if (m_transactionInfo.mode() == IDBTransactionMode::Versionchange)
        m_originalDatabaseInfo = makeUnique<IDBDatabaseInfo>(database->info());

    if (auto* manager = databaseConnection().manager())
        manager->registerTransaction(*this);
}

UniqueIDBDatabaseTransaction::~UniqueIDBDatabaseTransaction()
{
    if (auto* manager = databaseConnection().manager())
        manager->unregisterTransaction(*this);
}

UniqueIDBDatabaseConnection& UniqueIDBDatabaseTransaction::databaseConnection()



class IDBServer;
class UniqueIDBDatabaseConnection;

class UniqueIDBDatabaseTransaction : public CanMakeWeakPtr<UniqueIDBDatabaseTransaction>, public RefCounted<UniqueIDBDatabaseTransaction> {
public:
    static Ref<UniqueIDBDatabaseTransaction> create(UniqueIDBDatabaseConnection&, const IDBTransactionInfo&);



    UniqueIDBDatabaseConnection& databaseConnection();
    const IDBTransactionInfo& info() const { return m_transactionInfo; }
    WEBCORE_EXPORT bool isVersionChange() const;
    bool isReadOnly() const;

    IDBDatabaseInfo* originalDatabaseInfo() const;

    WEBCORE_EXPORT void abort();
    WEBCORE_EXPORT void abortWithoutCallback();
    WEBCORE_EXPORT void commit(uint64_t pendingRequestCount);

    WEBCORE_EXPORT void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&);
    WEBCORE_EXPORT void deleteObjectStore(const IDBRequestData&, const String& objectStoreName);
    WEBCORE_EXPORT void renameObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);
    WEBCORE_EXPORT void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier);
    WEBCORE_EXPORT void createIndex(const IDBRequestData&, const IDBIndexInfo&);
    WEBCORE_EXPORT void deleteIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);
    WEBCORE_EXPORT void renameIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);
    WEBCORE_EXPORT void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode);
    WEBCORE_EXPORT void getRecord(const IDBRequestData&, const IDBGetRecordData&);
    WEBCORE_EXPORT void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&);
    WEBCORE_EXPORT void getCount(const IDBRequestData&, const IDBKeyRangeData&);
    WEBCORE_EXPORT void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&);
    WEBCORE_EXPORT void openCursor(const IDBRequestData&, const IDBCursorInfo&);
    WEBCORE_EXPORT void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&);

    void didActivateInBackingStore(const IDBError&);


Lines 52-57 public: a/Source/WebCore/Modules/indexeddb/shared/IDBError.h_sec1
- a/Source/WebCore/Modules/indexeddb/shared/IDBError.h +1 lines
52	String message() const;	52	String message() const;
53		53
54	bool isNull() const { return !m_code; }	54	bool isNull() const { return !m_code; }
		55	operator bool() const { return !isNull(); }
55		56
56	WEBCORE_EXPORT IDBError isolatedCopy() const;	57	WEBCORE_EXPORT IDBError isolatedCopy() const;
57		58



    WEBCORE_EXPORT IDBRequestData isolatedCopy() const;

    IDBConnectionIdentifier serverConnectionIdentifier() const;
    WEBCORE_EXPORT IDBResourceIdentifier requestIdentifier() const;
    WEBCORE_EXPORT IDBResourceIdentifier transactionIdentifier() const;
    uint64_t objectStoreIdentifier() const;
    uint64_t indexIdentifier() const;
    IndexedDB::IndexRecordType indexRecordType() const;



    IDBResourceIdentifier(const IDBClient::IDBConnectionProxy&, const IDBRequest&);
    explicit IDBResourceIdentifier(const IDBServer::IDBConnectionToClient&);

    WEBCORE_EXPORT static IDBResourceIdentifier emptyValue();
    bool isEmpty() const
    {
        return !m_resourceNumber && !m_idbConnectionIdentifier;

        uint64_t hashCodes[2] = { m_idbConnectionIdentifier.toUInt64(), m_resourceNumber };
        return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
    }

    bool operator!=(const IDBResourceIdentifier& other) const { return !(*this == other); }
    bool operator==(const IDBResourceIdentifier& other) const
    {
        return m_idbConnectionIdentifier == other.m_idbConnectionIdentifier



		51123E2F276940CA00F9D41B /* NotificationData.h in Headers */ = {isa = PBXBuildFile; fileRef = 51123E2C27693C3200F9D41B /* NotificationData.h */; settings = {ATTRIBUTES = (Private, ); }; };
		5117F30E25E61020002A9F1E /* RemoteCommandListenerCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 5117F30C25E6101F002A9F1E /* RemoteCommandListenerCocoa.h */; };
		511EC1281C50AACA0032F983 /* IDBSerialization.h in Headers */ = {isa = PBXBuildFile; fileRef = 511EC1261C50AA570032F983 /* IDBSerialization.h */; };
		511EC12C1C50ABBF0032F983 /* SQLiteIDBTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 511EC12A1C50ABBA0032F983 /* SQLiteIDBTransaction.h */; settings = {ATTRIBUTES = (Private, ); }; };
		511EC1301C50ABF50032F983 /* SQLiteIDBCursor.h in Headers */ = {isa = PBXBuildFile; fileRef = 511EC12E1C50ABEC0032F983 /* SQLiteIDBCursor.h */; };
		5120BBAF1F1CECE700EFEBF1 /* CookieStorageObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 5120BBAD1F1CE77000EFEBF1 /* CookieStorageObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
		512BDB4B1C456FFA006494DF /* SQLiteIDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 512BDB491C456FAB006494DF /* SQLiteIDBBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
		512DD8F50D91E6AF000F89EE /* LegacyWebArchive.h in Headers */ = {isa = PBXBuildFile; fileRef = 512DD8EB0D91E6AF000F89EE /* LegacyWebArchive.h */; settings = {ATTRIBUTES = (Private, ); }; };
		512DD8F60D91E6AF000F89EE /* Archive.h in Headers */ = {isa = PBXBuildFile; fileRef = 512DD8EC0D91E6AF000F89EE /* Archive.h */; settings = {ATTRIBUTES = (Private, ); }; };
		512DD8F80D91E6AF000F89EE /* ArchiveResourceCollection.h in Headers */ = {isa = PBXBuildFile; fileRef = 512DD8EE0D91E6AF000F89EE /* ArchiveResourceCollection.h */; };

		516D7D721BB5F0BD00AF7C77 /* IDBConnectionToClientDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 516D7D6E1BB5F06500AF7C77 /* IDBConnectionToClientDelegate.h */; settings = {ATTRIBUTES = (Private, ); }; };
		516F7F6D1C31E39A00F111DC /* ServerOpenDBRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 516F7F6C1C31C79D00F111DC /* ServerOpenDBRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
		517138F01BED1D1A000D5F01 /* IndexKey.h in Headers */ = {isa = PBXBuildFile; fileRef = 517138EE1BED1D17000D5F01 /* IndexKey.h */; settings = {ATTRIBUTES = (Private, ); }; };
		517138F81BF128BB000D5F01 /* IndexValueStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 517138F61BF12262000D5F01 /* IndexValueStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
		517138FC1BF3ADF4000D5F01 /* IDBCursorInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 517138FA1BF3ADAC000D5F01 /* IDBCursorInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
		517139061BF64DEC000D5F01 /* MemoryObjectStoreCursor.h in Headers */ = {isa = PBXBuildFile; fileRef = 517139041BF64DE3000D5F01 /* MemoryObjectStoreCursor.h */; };
		517139081BF64DEF000D5F01 /* MemoryCursor.h in Headers */ = {isa = PBXBuildFile; fileRef = 517139021BF64DE3000D5F01 /* MemoryCursor.h */; };

		51B914101FD2782D00EE2859 /* RegistrationDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 51B9140C1FD2782500EE2859 /* RegistrationDatabase.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51B914111FD2782D00EE2859 /* RegistrationStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 51B9140B1FD2782500EE2859 /* RegistrationStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51BA4AC41BBB5CD800DF3D6D /* IDBDatabaseInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA4AC21BBB5CBF00DF3D6D /* IDBDatabaseInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51BA4ACB1BBC5BD900DF3D6D /* MemoryIDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA4AC91BBC5B9E00DF3D6D /* MemoryIDBBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51BA4ACC1BBC5BDD00DF3D6D /* IDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA4AC71BBC5AD600DF3D6D /* IDBBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51BA947123AC305300444846 /* RunJavaScriptParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA946F23AC305000444846 /* RunJavaScriptParameters.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51BCCE301F8F179E006BA0ED /* ServiceWorkerThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 517C87101F8EE72E00EB8076 /* ServiceWorkerThread.h */; settings = {ATTRIBUTES = (Private, ); }; };

		51E0BABB0DA5547100A9E417 /* StorageEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E0BAB90DA5547100A9E417 /* StorageEvent.h */; };
		51E0BAEB0DA55D4A00A9E417 /* JSStorageEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E0BAE90DA55D4A00A9E417 /* JSStorageEvent.h */; };
		51E0BB380DA5ACB600A9E417 /* StorageMap.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E0BB360DA5ACB600A9E417 /* StorageMap.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51E1BAC31BD8064E0055D81F /* MemoryBackingStoreTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E1BAC11BD806470055D81F /* MemoryBackingStoreTransaction.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51E269371DD3BD9B006B6A58 /* IDBIterateCursorData.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E269351DD3BD91006B6A58 /* IDBIterateCursorData.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51E399001D6E4750009C8831 /* GameControllerGamepad.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E398FC1D6E474B009C8831 /* GameControllerGamepad.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51E399021D6E4750009C8831 /* GameControllerGamepadProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E398FE1D6E474B009C8831 /* GameControllerGamepadProvider.h */; settings = {ATTRIBUTES = (Private, ); }; };

		51ECC3F8200587BF00483EAE /* MessagePortChannelRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = 51ECC3F1200587B500483EAE /* MessagePortChannelRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51ECC3FD2005930D00483EAE /* MessagePortChannelProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 51ECC3FB2005930100483EAE /* MessagePortChannelProvider.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51EE7B381AA50B0500F92B21 /* ResourceLoadInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 51EE7B371AA50B0500F92B21 /* ResourceLoadInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51EEAA741BEFFAB100218008 /* IndexValueEntry.h in Headers */ = {isa = PBXBuildFile; fileRef = 51EEAA721BEFFA7900218008 /* IndexValueEntry.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51F174FE1F35899200C74950 /* WorkerType.h in Headers */ = {isa = PBXBuildFile; fileRef = 51F174FC1F35898800C74950 /* WorkerType.h */; settings = {ATTRIBUTES = (Private, ); }; };
		51F175031F358B3B00C74950 /* JSServiceWorkerUpdateViaCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 51F175011F358B3600C74950 /* JSServiceWorkerUpdateViaCache.h */; };
		51F175061F358BF700C74950 /* JSWorkerType.h in Headers */ = {isa = PBXBuildFile; fileRef = 51F175051F358BDE00C74950 /* JSWorkerType.h */; };

		93B2D8160F9920D2006AE6B2 /* SuddenTermination.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B2D8150F9920D2006AE6B2 /* SuddenTermination.h */; settings = {ATTRIBUTES = (Private, ); }; };
		93B38EC325821DB400198E63 /* WebSpeechRecognizerTask.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B38EBA2582193B00198E63 /* WebSpeechRecognizerTask.h */; };
		93B38EC425821DB700198E63 /* WebSpeechRecognizerTaskMock.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B38EBB2582193D00198E63 /* WebSpeechRecognizerTaskMock.h */; };
		93B631E227ABA1E600443A44 /* UniqueIDBDatabaseManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B631E027ABA1E200443A44 /* UniqueIDBDatabaseManager.h */; settings = {ATTRIBUTES = (Private, ); }; };
		93B6A0E60B0BCA5C00F5027A /* ContextMenu.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B6A0E50B0BCA5C00F5027A /* ContextMenu.h */; settings = {ATTRIBUTES = (Private, ); }; };
		93B70D6409EB0C7C009D8468 /* JSDOMBinding.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B70D4809EB0C7C009D8468 /* JSDOMBinding.h */; settings = {ATTRIBUTES = (Private, ); }; };
		93B70D6A09EB0C7C009D8468 /* JSEventListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B70D4E09EB0C7C009D8468 /* JSEventListener.h */; settings = {ATTRIBUTES = (Private, ); }; };

		93B38EBA2582193B00198E63 /* WebSpeechRecognizerTask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSpeechRecognizerTask.h; sourceTree = "<group>"; };
		93B38EBB2582193D00198E63 /* WebSpeechRecognizerTaskMock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSpeechRecognizerTaskMock.h; sourceTree = "<group>"; };
		93B38EBC2582193E00198E63 /* WebSpeechRecognizerTask.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebSpeechRecognizerTask.mm; sourceTree = "<group>"; };
		93B631E027ABA1E200443A44 /* UniqueIDBDatabaseManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueIDBDatabaseManager.h; sourceTree = "<group>"; };
		93B6A0E50B0BCA5C00F5027A /* ContextMenu.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ContextMenu.h; sourceTree = "<group>"; };
		93B70D4809EB0C7C009D8468 /* JSDOMBinding.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSDOMBinding.h; sourceTree = "<group>"; };
		93B70D4D09EB0C7C009D8468 /* JSEventListener.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSEventListener.cpp; sourceTree = "<group>"; };

				518864DF1BBAF30F00E540C9 /* UniqueIDBDatabase.h */,
				5198F7A21BBDAA2900E2CC5F /* UniqueIDBDatabaseConnection.cpp */,
				5198F7A31BBDAA2900E2CC5F /* UniqueIDBDatabaseConnection.h */,
				93B631E027ABA1E200443A44 /* UniqueIDBDatabaseManager.h */,
				5198F7A61BBDD38100E2CC5F /* UniqueIDBDatabaseTransaction.cpp */,
				5198F7A71BBDD38100E2CC5F /* UniqueIDBDatabaseTransaction.h */,
			);

				A863E2011343412000274926 /* UnicodeBidi.h in Headers */,
				518864E11BBAF57400E540C9 /* UniqueIDBDatabase.h in Headers */,
				5198F7A51BBDB79300E2CC5F /* UniqueIDBDatabaseConnection.h in Headers */,
				93B631E227ABA1E600443A44 /* UniqueIDBDatabaseManager.h in Headers */,
				5198F7A91BBDD38500E2CC5F /* UniqueIDBDatabaseTransaction.h in Headers */,
				E4AFCFA50DAF29A300F5F55C /* UnitBezier.h in Headers */,
				C18CC0A42580EFB1003D75FB /* UniversalAccessZoom.h in Headers */,



#include "NetworkSocketChannelMessages.h"
#include "NetworkSocketStream.h"
#include "NetworkSocketStreamMessages.h"
#include "NetworkStorageManager.h"
#include "PingLoad.h"
#include "PreconnectTask.h"
#include "RTCDataChannelRemoteManagerProxy.h"
#include "ServiceWorkerFetchTaskMessages.h"
#include "WebCoreArgumentCoders.h"
#include "WebErrors.h"
#include "WebIDBServer.h"
#include "WebProcessMessages.h"
#include "WebProcessPoolMessages.h"
#include "WebResourceLoadStatisticsStore.h"


void NetworkConnectionToWebProcess::updateQuotaBasedOnSpaceUsageForTesting(const ClientOrigin& origin)
{
    auto* session = m_networkProcess->networkSession(sessionID());
    if (!session)
        return;

    if (auto* storageManager = session->storageManager())
        storageManager->resetQuotaUpdatedBasedOnUsageForTesting(origin);
}

void NetworkConnectionToWebProcess::didClose(IPC::Connection& connection)

        for (auto& file : fileReferences)
            file->revokeFileAccess();

        if (auto* session = networkSession()) {
            if (auto* storageManager = session->storageManager())
                storageManager->registerTemporaryBlobFilePaths(m_connection, filePaths);
        }
        completionHandler(WTFMove(filePaths));
    });
}



    // Make sure we flush all cookies to disk before exiting.
    forEachNetworkSession([&] (auto& session) {
        platformFlushCookies(session.sessionID(), [callbackAggregator] { });
        // Make sure reference to NetworkProcess in spaceRequester is removed.
        session.closeIDBServer([callbackAggregator] { });
    });
}


    connection.setOnLineState(NetworkStateNotifier::singleton().onLine());

    if (auto* session = networkSession(sessionID)) {
        session->ensureWebIDBServer().addConnection(connection.connection(), identifier);
        if (auto* manager = session->storageManager())
            manager->startReceivingMessageFromConnection(connection.connection());
    }

    addSessionStorageQuotaManager(sessionID, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota, parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);

    if (auto* session = networkSession(sessionID)) {
        session->addStorageManagerSession(parameters.generalStorageDirectory, parameters.generalStorageDirectoryHandle, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle, parameters.cacheStorageDirectory, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota);
        session->addIndexedDatabaseSession(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
#if ENABLE(SERVICE_WORKER)
        session->addServiceWorkerSession(parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
#endif

        callbackAggregator->m_websiteData.hostNamesWithHSTSCache = hostNamesWithHSTSCache(sessionID);
#endif

    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath()) {
        session->ensureWebIDBServer().getOrigins([callbackAggregator](auto&& origins) {
            while (!origins.isEmpty())
                callbackAggregator->m_websiteData.entries.append({ origins.takeAny(), WebsiteDataType::IndexedDBDatabases, 0 });
        });
    }

#if ENABLE(SERVICE_WORKER)
    if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {
        session->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {

    if (websiteDataTypes.contains(WebsiteDataType::DOMCache) && session)
        CacheStorage::Engine::clearAllCaches(*session, [clearTasksHandler] { });

    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral() && session)
        session->ensureWebIDBServer().closeAndDeleteDatabasesModifiedSince(modifiedSince, [clearTasksHandler] { });

#if ENABLE(SERVICE_WORKER)
    bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) || websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
    if (clearServiceWorkers && !sessionID.isEphemeral() && session)

            CacheStorage::Engine::clearCachesForOrigin(*session, SecurityOriginData { originData }, [clearTasksHandler] { });
    }

    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral() && session)
        session->ensureWebIDBServer().closeAndDeleteDatabasesForOrigins(originDatas, [clearTasksHandler] { });

#if ENABLE(SERVICE_WORKER)
    bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) || websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
    if (clearServiceWorkers && !sessionID.isEphemeral() && session) {

            }
        });
    }

    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath()) {
        session->ensureWebIDBServer().getOrigins([this, protectedThis = Ref { *this }, sessionID, callbackAggregator, domainsToDeleteAllNonCookieWebsiteDataFor](auto&& origins) {
            auto* session = networkSession(sessionID);
            if (!session || !session->webIDBServer())
                return;

            auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator->m_domains);
            session->webIDBServer()->closeAndDeleteDatabasesForOrigins(originsToDelete, [callbackAggregator] { });
        });
    }
    
#if ENABLE(SERVICE_WORKER)
    bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) || websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);

        });
    }
    
    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath()) {
        session->ensureWebIDBServer().getOrigins([callbackAggregator](auto&& origins) {
            while (!origins.isEmpty())
                callbackAggregator->m_websiteData.entries.append({ origins.takeAny(), WebsiteDataType::IndexedDBDatabases, 0 });
        });
    }
    
#if ENABLE(SERVICE_WORKER)
    if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {
        session->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {

    prepareToSuspend(true, WTFMove(completionHandler));
}

void NetworkProcess::suspendIDBServers(bool isSuspensionImminent)
{
    m_shouldSuspendIDBServers = true;
    ++m_suspensionIdentifier;

    bool allSuspended = true;
    auto condition = isSuspensionImminent ? WebIDBServer::SuspensionCondition::Always : WebIDBServer::SuspensionCondition::IfIdle;
    forEachNetworkSession([&](auto& session) {
        if (auto* server = session.webIDBServer())
            allSuspended &= server->suspend(condition);
    });

    if (allSuspended)
        return;

    RunLoop::main().dispatchAfter(5_s, [this, weakThis = WeakPtr { *this }, suspensionIdentifier = m_suspensionIdentifier] {
        if (!weakThis)
            return;

        if (!m_shouldSuspendIDBServers || suspensionIdentifier != m_suspensionIdentifier)
            return;

        forEachNetworkSession([](auto& session) {
            if (auto* server = session.webIDBServer())
                server->suspend(WebIDBServer::SuspensionCondition::Always);
        });
    });
}

void NetworkProcess::prepareToSuspend(bool isSuspensionImminent, CompletionHandler<void()>&& completionHandler)
{
    RELEASE_LOG(ProcessSuspension, "%p - NetworkProcess::prepareToSuspend(), isSuspensionImminent=%d", this, isSuspensionImminent);

#if PLATFORM(IOS_FAMILY)
    suspendIDBServers(isSuspensionImminent);
#endif

    lowMemoryHandler(Critical::Yes);

    RefPtr<CallbackAggregator> callbackAggregator = CallbackAggregator::create([this, completionHandler = WTFMove(completionHandler)]() mutable {

#if ENABLE(SERVICE_WORKER)
        if (auto* swServer = session.swServer())
            swServer->endSuspension();
#endif
#if PLATFORM(IOS_FAMILY)
        if (auto* server = session.webIDBServer())
            server->resume();
#endif
        if (auto* manager = session.storageManager())
            manager->resume();
    });

#if PLATFORM(IOS_FAMILY)
    m_shouldSuspendIDBServers = false;
#endif
}

void NetworkProcess::prefetchDNS(const String& hostname)


void NetworkProcess::resetQuota(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
{
    auto* session = networkSession(sessionID);
    if (!session)
        return completionHandler();

    if (auto* storageManager = session->storageManager())
        storageManager->resetQuotaForTesting(WTFMove(completionHandler));
}

void NetworkProcess::clearStorage(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)

        completionHandler();
}

void NetworkProcess::didIncreaseQuota(PAL::SessionID sessionID, const ClientOrigin& origin, QuotaIncreaseRequestIdentifier identifier, std::optional<uint64_t> newQuota)
{
    auto* session = networkSession(sessionID);
    if (!session)
        return;

    if (auto* manager = session->storageManager())
        manager->didIncreaseQuota(origin, identifier, newQuota);
}

void NetworkProcess::renameOriginInWebsiteData(PAL::SessionID sessionID, const URL& oldName, const URL& newName, OptionSet<WebsiteDataType> dataTypes, CompletionHandler<void()>&& completionHandler)
{
    auto aggregator = CallbackAggregator::create(WTFMove(completionHandler));

    auto* session = networkSession(sessionID);
    if (auto* manager = session ? session->storageManager() : nullptr)
        manager->moveData(oldOrigin, newOrigin, [aggregator] { });

    if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath())
        session->ensureWebIDBServer().renameOrigin(oldOrigin, newOrigin, [aggregator] { });
}

#if ENABLE(SERVICE_WORKER)

    StorageQuotaManager::UsageGetter usageGetter = [cacheRootPath = sessionStorageQuotaManager->cacheRootPath().isolatedCopy(), idbRootPath = idbRootPath.isolatedCopy(), origin = origin.isolatedCopy()]() {
        ASSERT(!isMainRunLoop());

        auto cacheStoragePath = CacheStorage::Engine::storagePath(cacheRootPath, origin);
        return CacheStorage::Engine::diskUsage(cacheStoragePath) + IDBServer::IDBServer::diskUsage(idbRootPath, origin);
    };
    StorageQuotaManager::QuotaIncreaseRequester quotaIncreaseRequester = [this, weakThis = WeakPtr { *this }, sessionID, origin] (uint64_t currentQuota, uint64_t currentSpace, uint64_t requestedIncrease, auto&& callback) {
        ASSERT(isMainRunLoop());

void NetworkProcess::connectionToWebProcessClosed(IPC::Connection& connection, PAL::SessionID sessionID)
{
    if (auto* session = networkSession(sessionID)) {
        if (auto* server = session->webIDBServer())
            server->removeConnection(connection);
        if (auto* manager = session->storageManager())
            manager->stopReceivingMessageFromConnection(connection);
    }



#include "LocalStorageDatabaseTracker.h"
#include "NetworkContentRuleListManager.h"
#include "NetworkResourceLoadIdentifier.h"
#include "QuotaIncreaseRequestIdentifier.h"
#include "RTCDataChannelRemoteManagerProxy.h"
#include "SandboxExtension.h"
#include "WebPageProxyIdentifier.h"

    NetworkContentRuleListManager& networkContentRuleListManager() { return m_networkContentRuleListManager; }
#endif

    bool shouldSuspendIDBServers() const { return m_shouldSuspendIDBServers; }

    void syncLocalStorage(CompletionHandler<void()>&&);

    void resetQuota(PAL::SessionID, CompletionHandler<void()>&&);
    void clearStorage(PAL::SessionID, CompletionHandler<void()>&&);
    void didIncreaseQuota(PAL::SessionID, const WebCore::ClientOrigin&, QuotaIncreaseRequestIdentifier, std::optional<uint64_t> newQuota);
    void renameOriginInWebsiteData(PAL::SessionID, const URL&, const URL&, OptionSet<WebsiteDataType>, CompletionHandler<void()>&&);

#if PLATFORM(IOS_FAMILY)

    void registerURLSchemeAsNoAccess(const String&) const;
    void registerURLSchemeAsCORSEnabled(const String&) const;

    void suspendIDBServers(bool isSuspensionImminent);

#if PLATFORM(IOS_FAMILY)
    void setIsHoldingLockedFiles(bool);
#endif

    class SessionStorageQuotaManager {
        WTF_MAKE_FAST_ALLOCATED;
    public:
        SessionStorageQuotaManager() = delete;
        SessionStorageQuotaManager(const String& cacheRootPath, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota)
            : m_cacheRootPath(cacheRootPath)
            , m_defaultQuota(defaultQuota)

    private:
        String m_cacheRootPath;
        String m_idbRootPath;
        uint64_t m_defaultQuota;
        uint64_t m_defaultThirdPartyQuota;
        HashMap<WebCore::ClientOrigin, RefPtr<WebCore::StorageQuotaManager>> m_storageQuotaManagers;
    };
    void addSessionStorageQuotaManager(PAL::SessionID, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota, const String& cacheRootPath, SandboxExtension::Handle&);

    WebSQLiteDatabaseTracker m_webSQLiteDatabaseTracker;
    RefPtr<ProcessAssertion> m_holdingLockedFileAssertion;
#endif

    bool m_shouldSuspendIDBServers { false };
    uint64_t m_suspensionIdentifier { 0 };
    
#if ENABLE(WEB_RTC)
    RefPtr<RTCDataChannelRemoteManagerProxy> m_rtcDataChannelProxy;

Lines 179-184 messages -> NetworkProcess LegacyReceiver { a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in_sec1
- a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in +1 lines
179		179
180	ResetQuota(PAL::SessionID sessionID) -> () Async	180	ResetQuota(PAL::SessionID sessionID) -> () Async
181	ClearStorage(PAL::SessionID sessionID) -> () Async	181	ClearStorage(PAL::SessionID sessionID) -> () Async
		182	DidIncreaseQuota(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, WebKit::QuotaIncreaseRequestIdentifier identifier, std::optional<uint64_t> newQuota)
182		183
183	#if ENABLE(APP_BOUND_DOMAINS)	184	#if ENABLE(APP_BOUND_DOMAINS)
184	HasAppBoundSession(PAL::SessionID sessionID) -> (bool hasAppBoundSession) Async	185	HasAppBoundSession(PAL::SessionID sessionID) -> (bool hasAppBoundSession) Async



    if (m_resourceLoadStatistics)
        m_resourceLoadStatistics->invalidateAndCancel();
#endif
    if (auto server = std::exchange(m_webIDBServer, nullptr))
        server->close();
    if (auto manager = std::exchange(m_storageManager, nullptr))
        manager->close();
    m_cacheEngine = nullptr;


#endif // ENABLE(SERVICE_WORKER)

void NetworkSession::addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle, const String& idbStoragePath, SandboxExtension::Handle& idbStoragePathHandle, const String& cacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyQuota)
{
    if (!m_webIDBServer) {
        String path;
        if (!sessionID().isEphemeral()) {
            ASSERT(!m_idbDatabasePath.isNull());
            path = m_idbDatabasePath;
        }

        auto spaceRequester = [networkProcess = Ref { networkProcess() }, sessionID = sessionID()](const auto& origin, uint64_t spaceRequested) {
            return networkProcess->storageQuotaManager(sessionID, origin)->requestSpaceOnBackgroundThread(spaceRequested);
        };

        m_webIDBServer = WebIDBServer::create(sessionID(), path, WTFMove(spaceRequester));
        if (networkProcess().shouldSuspendIDBServers())
            m_webIDBServer->suspend(WebIDBServer::SuspensionCondition::Always);
    }
    return *m_webIDBServer;
}

void NetworkSession::closeIDBServer(CompletionHandler<void()>&& completionHandler)
{
    if (!m_webIDBServer)
        return completionHandler();

    std::exchange(m_webIDBServer, nullptr)->close(WTFMove(completionHandler));
}

void NetworkSession::addIndexedDatabaseSession(const String& indexedDatabaseDirectory, SandboxExtension::Handle& handle)
{
    // *********
    // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
    // *********
    auto isNew = m_idbDatabasePath.isNull();
    m_idbDatabasePath = indexedDatabaseDirectory;
    if (isNew) {
        SandboxExtension::consumePermanently(handle);
        networkProcess().setSessionStorageQuotaManagerIDBRootPath(sessionID(), indexedDatabaseDirectory);
    }
}

void NetworkSession::addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle)
{
    if (m_storageManager)
        return;

    SandboxExtension::consumePermanently(generalStoragePathHandle);
    SandboxExtension::consumePermanently(localStoragePathHandle);
    SandboxExtension::consumePermanently(idbStoragePathHandle);
    IPC::Connection::UniqueID connectionID;
    if (auto* connection = networkProcess().parentProcessConnection())
        connectionID = connection->uniqueID();
    m_storageManager = NetworkStorageManager::create(sessionID(), connectionID, generalStoragePath, localStoragePath, idbStoragePath, cacheStoragePath, defaultOriginQuota, defaultThirdPartyQuota);
}

void NetworkSession::ensureCacheEngine(Function<void(CacheStorage::Engine&)>&& callback)



    void addServiceWorkerSession(bool processTerminationDelayEnabled, String&& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle&);
#endif

    WebIDBServer* webIDBServer() { return m_webIDBServer.get(); }
    WebIDBServer& ensureWebIDBServer();
    void closeIDBServer(CompletionHandler<void()>&&);
    void addIndexedDatabaseSession(const String& indexedDatabaseDirectory, SandboxExtension::Handle&);
    bool hasIDBDatabasePath() const { return !m_idbDatabasePath.isEmpty(); }

    NetworkStorageManager* storageManager() { return m_storageManager.get(); }
    void addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle, const String& idbStoragePath, SandboxExtension::Handle& idbStoragePathHandle, const String& cacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyQuota);

    CacheStorage::Engine* cacheEngine() { return m_cacheEngine.get(); }
    void ensureCacheEngine(Function<void(CacheStorage::Engine&)>&&);

    std::unique_ptr<WebCore::SWServer> m_swServer;
#endif

    String m_idbDatabasePath;
    RefPtr<WebIDBServer> m_webIDBServer;

    RefPtr<NetworkStorageManager> m_storageManager;
    RefPtr<CacheStorage::Engine> m_cacheEngine;
    Vector<Function<void(CacheStorage::Engine&)>> m_cacheStorageParametersCallbacks;



#include "NetworkCacheIOChannel.h"
#include "NetworkProcess.h"
#include "NetworkSession.h"
#include "NetworkStorageManager.h"
#include "WebsiteDataType.h"
#include <WebCore/CacheQueryOptions.h>
#include <WebCore/RetrieveRecordsOptions.h>

    return directorySize;
}

String Engine::storagePath(const String& rootDirectory, const WebCore::ClientOrigin& origin)
{
    ASSERT(!isMainRunLoop());
    
    if (rootDirectory.isEmpty())
        return emptyString();

    String saltPath = FileSystem::pathByAppendingComponent(rootDirectory, "salt"_s);
        return 0;

    String saltPath = FileSystem::pathByAppendingComponent(rootPath, "salt"_s);
    auto salt = FileSystem::readOrMakeSalt(saltPath);
    if (!salt)
        return emptyString();

    Key key(origin.topOrigin.toString(), origin.clientOrigin.toString(), { }, { }, *salt);
    return FileSystem::pathByAppendingComponent(rootDirectory, key.hashAsString());
}

uint64_t Engine::diskUsage(const String& originDirectory)
{
    ASSERT(!isMainRunLoop());

    if (originDirectory.isEmpty())
        return 0;

    String sizeFilePath = Caches::cachesSizeFilename(originDirectory);
    if (auto recordedSize = readSizeFile(sizeFilePath))
        return *recordedSize;

    return getDirectorySize(originDirectory);
}

void Engine::requestSpace(const WebCore::ClientOrigin& origin, uint64_t spaceRequested, CompletionHandler<void(bool)>&& callback)
{
    ASSERT(isMainThread());

    if (!m_networkProcess)
        callback(false);

    auto* session = m_networkProcess->networkSession(m_sessionID);
    if (!session)
        callback(false);

    if (auto* storageManager = session->storageManager())
        storageManager->requestSpace(origin, spaceRequested, WTFMove(callback));
}

Engine::Engine(NetworkSession& networkSession, String&& rootPath)



#include "NetworkCacheData.h"
#include "WebsiteData.h"
#include <WebCore/ClientOrigin.h>
#include <WebCore/StorageQuotaManager.h>
#include <pal/SessionID.h>
#include <wtf/HashMap.h>
#include <wtf/RefCounted.h>


    static void initializeQuotaUser(NetworkSession&, const WebCore::ClientOrigin&, CompletionHandler<void()>&&);

    static String storagePath(const String& rootDirectory, const WebCore::ClientOrigin&);
    static uint64_t diskUsage(const String& originDirectory);
    void requestSpace(const WebCore::ClientOrigin&, uint64_t spaceRequested, CompletionHandler<void(bool)>&&);

    bool shouldPersist() const { return !!m_ioQueue;}




        return;
    }

    m_engine->requestSpace(m_origin, spaceRequired, [callback = WTFMove(callback)](bool granted) mutable {
        if (!granted)
            return callback(Error::QuotaExceeded);
        callback({ });
            return;
        case WebCore::StorageQuotaManager::Decision::Grant:
            callback({ });
        };
    });
}




    // We synchronously take a process assertion when beginning a SQLite transaction so that we don't get suspended
    // while holding a locked file. We would get killed if suspended while holding locked files.
    m_holdingLockedFileAssertion = ProcessAssertion::create(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskInterruptable, ProcessAssertion::Mode::Sync);
    m_holdingLockedFileAssertion->setPrepareForInvalidationHandler([this, weakThis = WeakPtr { *this }]() mutable {
        ASSERT(isMainRunLoop());
        if (!weakThis)
            return;

        if (!m_shouldSuspendIDBServers)
            return;

        forEachNetworkSession([](auto& session) {
            if (auto* server = session.webIDBServer())
                server->suspend();
        });
    });
}

} // namespace WebKit



/*
 * Copyright (C) 2016-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.
 */

#include "config.h"
#include "IDBStorageConnectionToClient.h"

#include "WebCoreArgumentCoders.h"
#include "WebIDBConnectionToServerMessages.h"
#include "WebIDBResult.h"
#include <WebCore/IDBRequestData.h>
#include <WebCore/IDBResultData.h>
#include <WebCore/UniqueIDBDatabaseConnection.h>

namespace WebKit {

IDBStorageConnectionToClient::IDBStorageConnectionToClient(IPC::Connection::UniqueID connection, WebCore::IDBConnectionIdentifier identifier)
    : m_connection(connection)
    , m_identifier(identifier)
    , m_connectionToClient(WebCore::IDBServer::IDBConnectionToClient::create(*this))
{
}

IDBStorageConnectionToClient::~IDBStorageConnectionToClient()
{
    m_connectionToClient->clearDelegate();
}

WebCore::IDBServer::IDBConnectionToClient& IDBStorageConnectionToClient::connectionToClient()
{
    return m_connectionToClient;
}

template<class MessageType> void IDBStorageConnectionToClient::didGetResult(const WebCore::IDBResultData& resultData)
{
    if (resultData.type() == WebCore::IDBResultType::Error) {
        IPC::Connection::send(m_connection, MessageType(resultData), 0);
        return;
    }

    if (resultData.type() == WebCore::IDBResultType::GetAllRecordsSuccess && resultData.getAllResult().type() == WebCore::IndexedDB::GetAllType::Keys) {
        IPC::Connection::send(m_connection, MessageType(resultData), 0);
        return;
    }

    auto blobFilePaths = resultData.type() == WebCore::IDBResultType::GetAllRecordsSuccess ? resultData.getAllResult().allBlobFilePaths() : resultData.getResult().value().blobFilePaths();
    if (blobFilePaths.isEmpty()) {
        IPC::Connection::send(m_connection, MessageType(resultData), 0);
        return;
    }

    IPC::Connection::send(m_connection, MessageType(resultData), 0);
}

void IDBStorageConnectionToClient::didDeleteDatabase(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteDatabase(resultData), 0);
}

void IDBStorageConnectionToClient::didOpenDatabase(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidOpenDatabase(resultData), 0);
}

void IDBStorageConnectionToClient::didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidStartTransaction(transactionIdentifier, error), 0);
}

void IDBStorageConnectionToClient::didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidAbortTransaction(transactionIdentifier, error), 0);
}

void IDBStorageConnectionToClient::didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCommitTransaction(transactionIdentifier, error), 0);
}

void IDBStorageConnectionToClient::didCreateObjectStore(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCreateObjectStore(resultData), 0);
}

void IDBStorageConnectionToClient::didDeleteObjectStore(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteObjectStore(resultData), 0);
}

void IDBStorageConnectionToClient::didRenameObjectStore(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidRenameObjectStore(resultData), 0);
}

void IDBStorageConnectionToClient::didClearObjectStore(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidClearObjectStore(resultData), 0);
}

void IDBStorageConnectionToClient::didCreateIndex(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCreateIndex(resultData), 0);
}

void IDBStorageConnectionToClient::didDeleteIndex(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteIndex(resultData), 0);
}

void IDBStorageConnectionToClient::didRenameIndex(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidRenameIndex(resultData), 0);
}

void IDBStorageConnectionToClient::didPutOrAdd(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidPutOrAdd(resultData), 0);
}

void IDBStorageConnectionToClient::didGetRecord(const WebCore::IDBResultData& resultData)
{
    didGetResult<Messages::WebIDBConnectionToServer::DidGetRecord>(resultData);
}

void IDBStorageConnectionToClient::didGetAllRecords(const WebCore::IDBResultData& resultData)
{
    didGetResult<Messages::WebIDBConnectionToServer::DidGetAllRecords>(resultData);
}

void IDBStorageConnectionToClient::didGetCount(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidGetCount(resultData), 0);
}

void IDBStorageConnectionToClient::didDeleteRecord(const WebCore::IDBResultData& resultData)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteRecord(resultData), 0);
}

void IDBStorageConnectionToClient::didOpenCursor(const WebCore::IDBResultData& resultData)
{
    didGetResult<Messages::WebIDBConnectionToServer::DidOpenCursor>(resultData);
}

void IDBStorageConnectionToClient::didIterateCursor(const WebCore::IDBResultData& resultData)
{
    didGetResult<Messages::WebIDBConnectionToServer::DidIterateCursor>(resultData);
}

void IDBStorageConnectionToClient::didGetAllDatabaseNamesAndVersions(const WebCore::IDBResourceIdentifier& requestIdentifier, const Vector<WebCore::IDBDatabaseNameAndVersion>& databases)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidGetAllDatabaseNamesAndVersions(requestIdentifier, databases), 0);
}

void IDBStorageConnectionToClient::fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::FireVersionChangeEvent(connection.identifier(), requestIdentifier, requestedVersion), 0);
}

void IDBStorageConnectionToClient::didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBError& error)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCloseFromServer(connection.identifier(), error), 0);
}

void IDBStorageConnectionToClient::notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
{
    IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::NotifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion), 0);
}

} // namespace WebKit



/*
 * Copyright (C) 2016-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 "Connection.h"
#include <WebCore/IDBConnectionToClient.h>
#include <WebCore/IDBConnectionToClientDelegate.h>

namespace WebKit {

class IDBStorageConnectionToClient final : public WebCore::IDBServer::IDBConnectionToClientDelegate {
    WTF_MAKE_FAST_ALLOCATED;
public:
    IDBStorageConnectionToClient(IPC::Connection::UniqueID, WebCore::IDBConnectionIdentifier);
    ~IDBStorageConnectionToClient();

    WebCore::IDBConnectionIdentifier identifier() const final { return m_identifier; }
    IPC::Connection::UniqueID ipcConnection() const { return m_connection; }
    WebCore::IDBServer::IDBConnectionToClient& connectionToClient();

private:
    template<class MessageType> void didGetResult(const WebCore::IDBResultData&);

    // IDBConnectionToClientDelegate
    void didDeleteDatabase(const WebCore::IDBResultData&) final;
    void didOpenDatabase(const WebCore::IDBResultData&) final;
    void didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
    void didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
    void didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
    void didCreateObjectStore(const WebCore::IDBResultData&) final;
    void didDeleteObjectStore(const WebCore::IDBResultData&) final;
    void didRenameObjectStore(const WebCore::IDBResultData&) final;
    void didClearObjectStore(const WebCore::IDBResultData&) final;
    void didCreateIndex(const WebCore::IDBResultData&) final;
    void didDeleteIndex(const WebCore::IDBResultData&) final;
    void didRenameIndex(const WebCore::IDBResultData&) final;
    void didPutOrAdd(const WebCore::IDBResultData&) final;
    void didGetRecord(const WebCore::IDBResultData&) final;
    void didGetAllRecords(const WebCore::IDBResultData&) final;
    void didGetCount(const WebCore::IDBResultData&) final;
    void didDeleteRecord(const WebCore::IDBResultData&) final;
    void didOpenCursor(const WebCore::IDBResultData&) final;
    void didIterateCursor(const WebCore::IDBResultData&) final;
    void didGetAllDatabaseNamesAndVersions(const WebCore::IDBResourceIdentifier&, const Vector<WebCore::IDBDatabaseNameAndVersion>&) final;
    void notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion) final;
    void fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion) final;
    void didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBError&) final;

    IPC::Connection::UniqueID m_connection;
    WebCore::IDBConnectionIdentifier m_identifier;
    Ref<WebCore::IDBServer::IDBConnectionToClient> m_connectionToClient;
};

} // namespace WebKit



/*
 * 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.
 */

#include "config.h"
#include "IDBStorageManager.h"

#include "IDBStorageRegistry.h"
#include <WebCore/MemoryIDBBackingStore.h>
#include <WebCore/SQLiteFileSystem.h>
#include <WebCore/SQLiteIDBBackingStore.h>

namespace WebKit {

static void migrateOriginData(const String& oldOriginDirectory, const String& newOriginDirectory)
{
    if (!FileSystem::fileExists(oldOriginDirectory))
        return;

    auto fileNames = FileSystem::listDirectory(oldOriginDirectory);
    for (auto name : fileNames) {
        String childPath = FileSystem::getSymbolicLinkTarget(FileSystem::pathByAppendingComponent(oldOriginDirectory, name));
        String newName = WebCore::SQLiteFileSystem::computeHashForFileName(WebCore::IDBServer::SQLiteIDBBackingStore::decodeDatabaseName(name));
        auto newChildPath = FileSystem::pathByAppendingComponent(newOriginDirectory, newName);
        FileSystem::moveFile(childPath, newChildPath);
    }

    FileSystem::deleteEmptyDirectory(oldOriginDirectory);
}

String IDBStorageManager::idbStorageOriginDirectory(const String& rootDirectory, const WebCore::ClientOrigin& origin)
{
    if (rootDirectory.isEmpty())
        return emptyString();

    String originDirectory = WebCore::IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(origin.topOrigin, origin.clientOrigin, rootDirectory, "v1");
    FileSystem::makeAllDirectories(originDirectory);

    String oldOriginDirectory = WebCore::IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(origin.topOrigin, origin.clientOrigin, rootDirectory, "v0");
    migrateOriginData(oldOriginDirectory, originDirectory);

    return originDirectory;
}

uint64_t IDBStorageManager::idbStorageSize(const String& originDirectory)
{
    if (originDirectory.isEmpty())
        return 0;

    return WebCore::IDBServer::SQLiteIDBBackingStore::databasesSizeForDirectory(originDirectory);
}

static void getOriginsForVersion(const String& versionPath, HashSet<WebCore::ClientOrigin>& origins)
{
    for (auto& topDatabaseIdentifier : FileSystem::listDirectory(versionPath)) {
        auto topOrigin = WebCore::SecurityOriginData::fromDatabaseIdentifier(topDatabaseIdentifier);
        if (!topOrigin)
            continue;

        for (auto& databaseIdentifier : FileSystem::listDirectory(FileSystem::pathByAppendingComponent(versionPath, topDatabaseIdentifier))) {
            if (auto clientOrigin = WebCore::SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
                origins.add(WebCore::ClientOrigin { *topOrigin, *clientOrigin });
            else
                origins.add(WebCore::ClientOrigin { *topOrigin, *topOrigin });
        }
    }
}

HashSet<WebCore::ClientOrigin> IDBStorageManager::originsOfIDBStorageData(const String& rootDirectory)
{
    HashSet<WebCore::ClientOrigin> origins;
    if (rootDirectory.isEmpty())
        return origins;

    getOriginsForVersion(FileSystem::pathByAppendingComponent(rootDirectory, "v0"), origins);
    getOriginsForVersion(FileSystem::pathByAppendingComponent(rootDirectory, "v1"), origins);
    return origins;
}

IDBStorageManager::IDBStorageManager(const String& path, IDBStorageRegistry& registry, QuotaCheckFunction&& quotaCheckFunction)
    : m_path(path)
    , m_registry(registry)
    , m_quotaCheckFunction(WTFMove(quotaCheckFunction))
{
}

bool IDBStorageManager::isActive() const
{
    return !m_databases.isEmpty();
}

bool IDBStorageManager::hasDataInMemory() const
{
    return WTF::anyOf(m_databases.values(), [&] (auto& database) {
        return database->hasDataInMemory();
    });
}

void IDBStorageManager::closeDatabasesForDeletion()
{
    for (auto& database : m_databases.values())
        database->immediateClose();

    m_databases.clear();
}

void IDBStorageManager::stopDatabaseActivitiesForSuspend()
{
    if (m_path.isEmpty())
        return;

    for (auto& database : m_databases.values()) {
        // Only stop databases with non-ephemeral backing store that can hold database file lock.
        if (!database->identifier().isTransient())
            database->abortInProgressTransactions();
    }
}

WebCore::IDBServer::UniqueIDBDatabase& IDBStorageManager::getOrCreateUniqueIDBDatabase(const WebCore::IDBDatabaseIdentifier& identifier)
{
    auto addResult = m_databases.add(identifier, nullptr);
    if (addResult.isNewEntry)
        addResult.iterator->value = makeUnique<WebCore::IDBServer::UniqueIDBDatabase>(*this, identifier);

    return *addResult.iterator->value;
}

void IDBStorageManager::openDatabase(WebCore::IDBServer::IDBConnectionToClient& connectionToClient, const WebCore::IDBRequestData& requestData)
{
    auto& database = getOrCreateUniqueIDBDatabase(requestData.databaseIdentifier());
    database.openDatabaseConnection(connectionToClient, requestData);
}

void IDBStorageManager::deleteDatabase(WebCore::IDBServer::IDBConnectionToClient& connectionToClient, const WebCore::IDBRequestData& requestData)
{
    auto& database = getOrCreateUniqueIDBDatabase(requestData.databaseIdentifier());
    database.handleDelete(connectionToClient, requestData);

    // This database is created for deletion.
    if (database.tryClose())
        m_databases.remove(database.identifier());
}

Vector<WebCore::IDBDatabaseNameAndVersion> IDBStorageManager::getAllDatabaseNamesAndVersions()
{
    Vector<WebCore::IDBDatabaseNameAndVersion> result;
    HashSet<String> visitedDatabasePaths;
    for (auto& database : m_databases.values()) {
        auto path = database->filePath();
        if (!path.isEmpty())
            visitedDatabasePaths.add(path);

        if (auto nameAndVersion = database->nameAndVersion())
            result.append(WTFMove(*nameAndVersion));
    }

    auto databaseIdentifiers = FileSystem::listDirectory(m_path);
    for (auto identifier : databaseIdentifiers) {
        auto databaseDirectory = FileSystem::pathByAppendingComponent(m_path, identifier);
        auto databasePath = WebCore::IDBServer::SQLiteIDBBackingStore::fullDatabasePathForDirectory(databaseDirectory);
        if (visitedDatabasePaths.contains(databasePath))
            continue;

        if (auto nameAndVersion = WebCore::IDBServer::SQLiteIDBBackingStore::databaseNameAndVersionFromFile(databasePath))
            result.append(WTFMove(*nameAndVersion));
    }

    return result;
}

void IDBStorageManager::openDBRequestCancelled(const WebCore::IDBRequestData& requestData)
{
    auto* database = m_databases.get(requestData.databaseIdentifier());
    if (!database)
        return;

    database->openDBRequestCancelled(requestData.requestIdentifier());

    // Database becomes idle after request is cancelled.
    if (database->tryClose())
        m_databases.remove(database->identifier());
}

void IDBStorageManager::registerConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection)
{
    m_registry.registerConnection(connection);
}

void IDBStorageManager::unregisterConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection)
{
    m_registry.unregisterConnection(connection);
}

void IDBStorageManager::registerTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction& transaction)
{
    m_registry.registerTransaction(transaction);
}

void IDBStorageManager::unregisterTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction& transaction)
{
    m_registry.unregisterTransaction(transaction);
}

std::unique_ptr<WebCore::IDBServer::IDBBackingStore> IDBStorageManager::createBackingStore(const WebCore::IDBDatabaseIdentifier& identifier)
{
    if (m_path.isEmpty())
        return makeUnique<WebCore::IDBServer::MemoryIDBBackingStore>(identifier);

    if (identifier.isTransient())
        return makeUnique<WebCore::IDBServer::MemoryIDBBackingStore>(identifier);

    auto name = WebCore::SQLiteFileSystem::computeHashForFileName(identifier.databaseName());
    return makeUnique<WebCore::IDBServer::SQLiteIDBBackingStore>(identifier, FileSystem::pathByAppendingComponent(m_path, name));
}

void IDBStorageManager::requestSpace(const WebCore::ClientOrigin&, uint64_t size, CompletionHandler<void(bool)>&& completionHandler)
{
    m_quotaCheckFunction(size, WTFMove(completionHandler));
}

} // namespace WebKit



/*
 * 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 <WebCore/UniqueIDBDatabaseManager.h>

namespace WebCore {
namespace IDBServer {
class IDBBackingStore;
class IDBConnectionToClient;
class UniqueIDBDatabase;
class UniqueIDBTransaction;
}

struct IDBDatabaseNameAndVersion;
}

namespace WebKit {

class IDBStorageRegistry;

class IDBStorageManager final : public WebCore::IDBServer::UniqueIDBDatabaseManager {
public:
    static String idbStorageOriginDirectory(const String& rootDirectory, const WebCore::ClientOrigin&);
    static uint64_t idbStorageSize(const String& originDirectory);
    static HashSet<WebCore::ClientOrigin> originsOfIDBStorageData(const String& rootDirectory);

    using QuotaCheckFunction = Function<void(uint64_t spaceRequested, CompletionHandler<void(bool)>&&)>;
    IDBStorageManager(const String& path, IDBStorageRegistry&, QuotaCheckFunction&&);
    ~IDBStorageManager() final { }
    bool isActive() const;
    bool hasDataInMemory() const;
    void closeDatabasesForDeletion();
    void stopDatabaseActivitiesForSuspend();

    void openDatabase(WebCore::IDBServer::IDBConnectionToClient&, const WebCore::IDBRequestData&);
    void openDBRequestCancelled(const WebCore::IDBRequestData&);
    void deleteDatabase(WebCore::IDBServer::IDBConnectionToClient&, const WebCore::IDBRequestData&);
    Vector<WebCore::IDBDatabaseNameAndVersion> getAllDatabaseNamesAndVersions();

private:
    WebCore::IDBServer::UniqueIDBDatabase& getOrCreateUniqueIDBDatabase(const WebCore::IDBDatabaseIdentifier&);

    // WebCore::UniqueIDBDatabaseManager
    void registerConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection&) final;
    void unregisterConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection&) final;
    void registerTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&) final;
    void unregisterTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&) final;
    std::unique_ptr<WebCore::IDBServer::IDBBackingStore> createBackingStore(const WebCore::IDBDatabaseIdentifier&) final;
    void requestSpace(const WebCore::ClientOrigin&, uint64_t size, CompletionHandler<void(bool)>&&) final;

    String m_path;
    IDBStorageRegistry& m_registry;
    QuotaCheckFunction m_quotaCheckFunction;
    HashMap<WebCore::IDBDatabaseIdentifier, std::unique_ptr<WebCore::IDBServer::UniqueIDBDatabase>> m_databases;
};

} // namespace WebKit



/*
 * 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.
 */

#include "config.h"
#include "IDBStorageRegistry.h"

#include "IDBStorageConnectionToClient.h"
#include <WebCore/UniqueIDBDatabaseConnection.h>
#include <WebCore/UniqueIDBDatabaseTransaction.h>

namespace WebKit {

IDBStorageRegistry::IDBStorageRegistry() = default;

WebCore::IDBServer::IDBConnectionToClient& IDBStorageRegistry::getOrCreateConnectionToClient(IPC::Connection::UniqueID connection, WebCore::IDBConnectionIdentifier identifier)
{
    auto addResult = m_connectionsToClient.add(identifier, nullptr);
    if (addResult.isNewEntry)
        addResult.iterator->value = makeUnique<IDBStorageConnectionToClient>(connection, identifier);

    ASSERT(addResult.iterator->value->ipcConnection() == connection);
    return addResult.iterator->value->connectionToClient();
}

void IDBStorageRegistry::removeConnectionToClient(IPC::Connection::UniqueID connection)
{
    auto allConnectionsToClient = std::exchange(m_connectionsToClient, { });
    for (auto& [identifier, connectionToClient] : allConnectionsToClient) {
        if (connectionToClient->ipcConnection() != connection) {
            m_connectionsToClient.add(identifier, WTFMove(connectionToClient));
            continue;
        }
        connectionToClient->connectionToClient().connectionToClientClosed();
    }
}

void IDBStorageRegistry::registerConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection)
{
    auto identifier = connection.identifier();
    ASSERT(!m_connections.contains(identifier));

    m_connections.add(identifier, connection);
}

void IDBStorageRegistry::unregisterConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection)
{
    auto identifier = connection.identifier();
    ASSERT(m_connections.contains(identifier));

    m_connections.remove(identifier);
}

void IDBStorageRegistry::registerTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction& transaction)
{
    auto identifier = transaction.info().identifier();
    ASSERT(!m_transactions.contains(identifier));

    m_transactions.add(identifier, transaction);
}

void IDBStorageRegistry::unregisterTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction& transaction)
{
    auto identifier = transaction.info().identifier();
    ASSERT(m_transactions.contains(identifier));

    m_transactions.remove(identifier);
}

WebCore::IDBServer::UniqueIDBDatabaseConnection* IDBStorageRegistry::getConnection(uint64_t identifier)
{
    return m_connections.get(identifier).get();
}

WebCore::IDBServer::UniqueIDBDatabaseTransaction* IDBStorageRegistry::getTransaction(WebCore::IDBResourceIdentifier identifier)
{
    return m_transactions.get(identifier).get();
}

} // namespace WebKit



/*
 * Copyright (C) 2021 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 "Connection.h"
#include <WebCore/IDBResourceIdentifier.h>
#include <wtf/WeakPtr.h>

namespace WebCore {
namespace IDBServer {
class UniqueIDBDatabaseConnection;
class UniqueIDBDatabaseTransaction;
}
}

namespace WebKit {

class IDBStorageConnectionToClient;

class IDBStorageRegistry {
    WTF_MAKE_FAST_ALLOCATED;
public:
    IDBStorageRegistry();
    WebCore::IDBServer::IDBConnectionToClient& getOrCreateConnectionToClient(IPC::Connection::UniqueID, WebCore::IDBConnectionIdentifier);
    void removeConnectionToClient(IPC::Connection::UniqueID);
    void registerConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection&);
    void unregisterConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection&);
    WebCore::IDBServer::UniqueIDBDatabaseConnection* getConnection(uint64_t identifier);
    void registerTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&);
    void unregisterTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&);
    WebCore::IDBServer::UniqueIDBDatabaseTransaction* getTransaction(WebCore::IDBResourceIdentifier);

private:
    HashMap<WebCore::IDBConnectionIdentifier, std::unique_ptr<IDBStorageConnectionToClient>> m_connectionsToClient;
    HashMap<uint64_t, WeakPtr<WebCore::IDBServer::UniqueIDBDatabaseConnection>> m_connections;
    HashMap<WebCore::IDBResourceIdentifier, WeakPtr<WebCore::IDBServer::UniqueIDBDatabaseTransaction>> m_transactions;
};

} // namespace WebKit

Lines 26-43 a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec1
- a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp -8 / +284 lines
26	#include "config.h"	26	#include "config.h"
27	#include "NetworkStorageManager.h"	27	#include "NetworkStorageManager.h"
28		28
		29	#include "CacheStorageEngine.h"
29	#include "FileSystemStorageHandleRegistry.h"	30	#include "FileSystemStorageHandleRegistry.h"
30	#include "FileSystemStorageManager.h"	31	#include "FileSystemStorageManager.h"
		32	#include "IDBStorageConnectionToClient.h"
		33	#include "IDBStorageManager.h"
		34	#include "IDBStorageRegistry.h"
31	#include "LocalStorageManager.h"	35	#include "LocalStorageManager.h"
32	#include "Logging.h"	36	#include "Logging.h"
		37	#include "NetworkProcessProxyMessages.h"
33	#include "NetworkStorageManagerMessages.h"	38	#include "NetworkStorageManagerMessages.h"
34	#include "OriginStorageManager.h"	39	#include "OriginStorageManager.h"
		40	#include "QuotaManager.h"
35	#include "SessionStorageManager.h"	41	#include "SessionStorageManager.h"
36	#include "StorageAreaBase.h"	42	#include "StorageAreaBase.h"
37	#include "StorageAreaMapMessages.h"	43	#include "StorageAreaMapMessages.h"
38	#include "StorageAreaRegistry.h"	44	#include "StorageAreaRegistry.h"
39	#include "WebsiteDataType.h"	45	#include "WebsiteDataType.h"
40	#include <WebCore/SecurityOriginData.h>	46	#include <WebCore/SecurityOriginData.h>
		47	#include <WebCore/UniqueIDBDatabaseConnection.h>
		48	#include <WebCore/UniqueIDBDatabaseTransaction.h>
41	#include <pal/crypto/CryptoDigest.h>	49	#include <pal/crypto/CryptoDigest.h>
42	#include <wtf/Scope.h>	50	#include <wtf/Scope.h>
43	#include <wtf/SuspendableWorkQueue.h>	51	#include <wtf/SuspendableWorkQueue.h>
Lines 100-121 static void deleteOriginFileIfNecessary(const String& filePath) a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec2
100	FileSystem::deleteFile(filePath);	108	FileSystem::deleteFile(filePath);
101	}	109	}
102		110
103	Ref<NetworkStorageManager> NetworkStorageManager::create(PAL::SessionID sessionID, const String& path, const String& customLocalStoragePath)	111	Ref<NetworkStorageManager> NetworkStorageManager::create(PAL::SessionID sessionID, IPC::Connection::UniqueID connection, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyOriginQuota)
104	{	112	{
105	return adoptRef(*new NetworkStorageManager(sessionID, path, customLocalStoragePath));	113	return adoptRef(*new NetworkStorageManager(sessionID, connection, path, customLocalStoragePath, customIDBStoragePath, customCacheStoragePath, defaultOriginQuota, defaultThirdPartyOriginQuota));
106	}	114	}
107		115
108	NetworkStorageManager::NetworkStorageManager(PAL::SessionID sessionID, const String& path, const String& customLocalStoragePath)	116	NetworkStorageManager::NetworkStorageManager(PAL::SessionID sessionID, IPC::Connection::UniqueID connection, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyOriginQuota)
109	: m_sessionID(sessionID)	117	: m_sessionID(sessionID)
110	, m_queue(SuspendableWorkQueue::create("com.apple.WebKit.Storage"))	118	, m_queue(SuspendableWorkQueue::create("com.apple.WebKit.Storage"))
		119	, m_defaultOriginQuota(defaultOriginQuota)
		120	, m_defaultThirdPartyOriginQuota(defaultThirdPartyOriginQuota)
		121	, m_parentConnection(connection)
111	{	122	{
112	ASSERT(RunLoop::isMain());	123	ASSERT(RunLoop::isMain());
113		124
114	m_queue->dispatch([this, protectedThis = Ref { *this }, path = path.isolatedCopy(), customLocalStoragePath = crossThreadCopy(customLocalStoragePath)]() mutable {	125	m_queue->dispatch([this, protectedThis = Ref { *this }, path = path.isolatedCopy(), customLocalStoragePath = crossThreadCopy(customLocalStoragePath), customIDBStoragePath = crossThreadCopy(customIDBStoragePath), customCacheStoragePath = crossThreadCopy(customCacheStoragePath)]() mutable {
115	m_fileSystemStorageHandleRegistry = makeUnique<FileSystemStorageHandleRegistry>();	126	m_fileSystemStorageHandleRegistry = makeUnique<FileSystemStorageHandleRegistry>();
116	m_storageAreaRegistry = makeUnique<StorageAreaRegistry>();	127	m_storageAreaRegistry = makeUnique<StorageAreaRegistry>();
		128	m_idbStorageRegistry = makeUnique<IDBStorageRegistry>();
117	m_path = path;	129	m_path = path;
118	m_customLocalStoragePath = customLocalStoragePath;	130	m_customLocalStoragePath = customLocalStoragePath;
		131	m_customIDBStoragePath = customIDBStoragePath;
		132	m_customCacheStoragePath = customCacheStoragePath;
119	if (!m_path.isEmpty()) {	133	if (!m_path.isEmpty()) {
120	auto saltPath = FileSystem::pathByAppendingComponent(m_path, "salt");	134	auto saltPath = FileSystem::pathByAppendingComponent(m_path, "salt");
121	m_salt = valueOrDefault(FileSystem::readOrMakeSalt(saltPath));	135	m_salt = valueOrDefault(FileSystem::readOrMakeSalt(saltPath));
Lines 131-137 NetworkStorageManager::~NetworkStorageManager() a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec3
131		145
132	bool NetworkStorageManager::canHandleTypes(OptionSet<WebsiteDataType> types)	146	bool NetworkStorageManager::canHandleTypes(OptionSet<WebsiteDataType> types)
133	{	147	{
134	return types.contains(WebsiteDataType::LocalStorage) \|\| types.contains(WebsiteDataType::SessionStorage) \|\| types.contains(WebsiteDataType::FileSystem);	148	return types.contains(WebsiteDataType::LocalStorage)
		149	\|\| types.contains(WebsiteDataType::SessionStorage)
		150	\|\| types.contains(WebsiteDataType::FileSystem)
		151	\|\| types.contains(WebsiteDataType::IndexedDBDatabases);
135	}	152	}
136		153
137	void NetworkStorageManager::close()	154	void NetworkStorageManager::close()
Lines 170-175 void NetworkStorageManager::stopReceivingMessageFromConnection(IPC::Connection& a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec4
170		187
171	connection.removeWorkQueueMessageReceiver(Messages::NetworkStorageManager::messageReceiverName());	188	connection.removeWorkQueueMessageReceiver(Messages::NetworkStorageManager::messageReceiverName());
172	m_queue->dispatch([this, protectedThis = Ref { *this }, connection = connection.uniqueID()]() mutable {	189	m_queue->dispatch([this, protectedThis = Ref { *this }, connection = connection.uniqueID()]() mutable {
		190	m_idbStorageRegistry->removeConnectionToClient(connection);
173	m_localOriginStorageManagers.removeIf([&](auto& entry) {	191	m_localOriginStorageManagers.removeIf([&](auto& entry) {
174	auto& manager = entry.value;	192	auto& manager = entry.value;
175	manager->connectionClosed(connection);	193	manager->connectionClosed(connection);
Lines 222-228 OriginStorageManager& NetworkStorageManager::localOriginStorageManager(const Web a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec5
222	writeOriginToFileIfNecessary(originFilePath(originDirectory), origin);	240	writeOriginToFileIfNecessary(originFilePath(originDirectory), origin);
223	});	241	});
224	}	242	}
225	return makeUnique<OriginStorageManager>(WTFMove(originDirectory), LocalStorageManager::localStorageFilePath(m_customLocalStoragePath, origin));	243	auto localStoragePath = LocalStorageManager::localStorageFilePath(m_customLocalStoragePath, origin);
		244	auto idbStoragePath = IDBStorageManager::idbStorageOriginDirectory(m_customIDBStoragePath, origin);
		245	auto cacheStoragePath = CacheStorage::Engine::storagePath(m_customCacheStoragePath, origin);
		246	uint64_t quota = origin.topOrigin == origin.clientOrigin ? m_defaultOriginQuota : m_defaultThirdPartyOriginQuota;
		247	QuotaManager::IncreaseQuotaFunction increaseQuotaFunction = [sessionID = m_sessionID, origin, connection = m_parentConnection] (auto identifier, auto currentQuota, auto currentUsage, auto requestedIncrease) mutable {
		248	IPC::Connection::send(connection, Messages::NetworkProcessProxy::IncreaseQuota(sessionID, origin, identifier, currentQuota, currentUsage, requestedIncrease), 0);
		249	};
		250	return makeUnique<OriginStorageManager>(quota, WTFMove(increaseQuotaFunction), WTFMove(originDirectory), WTFMove(localStoragePath), WTFMove(idbStoragePath), WTFMove(cacheStoragePath));
226	}).iterator->value;	251	}).iterator->value;
227	}	252	}
228		253
Lines 282-287 void NetworkStorageManager::clearStorageForTesting(CompletionHandler<void()>&& c a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec6
282	});	307	});
283	}	308	}
284		309
		310	void NetworkStorageManager::didIncreaseQuota(const WebCore::ClientOrigin& origin, QuotaIncreaseRequestIdentifier identifier, std::optional<uint64_t> newQuota)
		311	{
		312	ASSERT(RunLoop::isMain());
		313
		314	m_queue->dispatch([this, protectedThis = Ref { *this }, origin = crossThreadCopy(origin), identifier, newQuota]() mutable {
		315	if (auto manager = m_localOriginStorageManagers.get(origin))
		316	manager->quotaManager().didIncreaseQuota(identifier, newQuota);
		317	});
		318	}
		319
285	void NetworkStorageManager::fileSystemGetDirectory(IPC::Connection& connection, const WebCore::ClientOrigin& origin, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&& completionHandler)	320	void NetworkStorageManager::fileSystemGetDirectory(IPC::Connection& connection, const WebCore::ClientOrigin& origin, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&& completionHandler)
286	{	321	{
287	ASSERT(!RunLoop::isMain());	322	ASSERT(!RunLoop::isMain());
Lines 452-457 HashSet<WebCore::ClientOrigin> NetworkStorageManager::getAllOrigins() a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec7
452	for (auto& origin : LocalStorageManager::originsOfLocalStorageData(m_customLocalStoragePath))	487	for (auto& origin : LocalStorageManager::originsOfLocalStorageData(m_customLocalStoragePath))
453	allOrigins.add(WebCore::ClientOrigin { origin, origin });	488	allOrigins.add(WebCore::ClientOrigin { origin, origin });
454		489
		490	for (auto& origin : IDBStorageManager::originsOfIDBStorageData(m_customIDBStoragePath))
		491	allOrigins.add(origin);
		492
455	return allOrigins;	493	return allOrigins;
456	}	494	}
457		495
Lines 579-590 void NetworkStorageManager::moveData(const WebCore::SecurityOriginData& source, a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec8
579	auto targetOrigin = WebCore::ClientOrigin { target, target };	617	auto targetOrigin = WebCore::ClientOrigin { target, target };
580		618
581	// Clear existing data of target origin.	619	// Clear existing data of target origin.
582	OptionSet<WebsiteDataType> types = { WebsiteDataType::FileSystem, WebsiteDataType::LocalStorage, WebsiteDataType::SessionStorage };	620	OptionSet<WebsiteDataType> types = { WebsiteDataType::FileSystem, WebsiteDataType::LocalStorage, WebsiteDataType::SessionStorage, WebsiteDataType::IndexedDBDatabases };
583	localOriginStorageManager(targetOrigin).deleteData(types, -WallTime::infinity());	621	localOriginStorageManager(targetOrigin).deleteData(types, -WallTime::infinity());
584	removeOriginStorageManagerIfPossible(targetOrigin);	622	removeOriginStorageManagerIfPossible(targetOrigin);
585		623
586	// Move data from source origin to target origin.	624	// Move data from source origin to target origin.
587	localOriginStorageManager(sourceOrigin).moveData(originDirectoryPath(m_path, targetOrigin, m_salt), LocalStorageManager::localStorageFilePath(m_customLocalStoragePath, targetOrigin));	625	localOriginStorageManager(sourceOrigin).moveData(originDirectoryPath(m_path, targetOrigin, m_salt), LocalStorageManager::localStorageFilePath(m_customLocalStoragePath, targetOrigin), IDBStorageManager::idbStorageOriginDirectory(m_customIDBStoragePath, targetOrigin));
588	removeOriginStorageManagerIfPossible(sourceOrigin);	626	removeOriginStorageManagerIfPossible(sourceOrigin);
589		627
590	RunLoop::main().dispatch(WTFMove(completionHandler));	628	RunLoop::main().dispatch(WTFMove(completionHandler));
Lines 599-604 void NetworkStorageManager::suspend(CompletionHandler<void()>&& completionHandle a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec9
599	for (auto& manager : m_localOriginStorageManagers.values()) {	637	for (auto& manager : m_localOriginStorageManagers.values()) {
600	if (auto localStorageManager = manager->existingLocalStorageManager())	638	if (auto localStorageManager = manager->existingLocalStorageManager())
601	localStorageManager->syncLocalStorage();	639	localStorageManager->syncLocalStorage();
		640	if (auto idbStorageManager = manager->existingIDBStorageManager())
		641	idbStorageManager->stopDatabaseActivitiesForSuspend();
602	}	642	}
603	}, WTFMove(completionHandler));	643	}, WTFMove(completionHandler));
604	}	644	}
Lines 636-641 void NetworkStorageManager::syncLocalStorage(CompletionHandler<void()>&& complet a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec10
636	});	676	});
637	}	677	}
638		678
		679	void NetworkStorageManager::registerTemporaryBlobFilePaths(IPC::Connection& connection, const Vector<String>& filePaths)
		680	{
		681	ASSERT(RunLoop::isMain());
		682
		683	m_queue->dispatch([this, protectedThis = Ref { *this }, connectionID = connection.uniqueID(), filePaths = crossThreadCopy(filePaths)] {
		684	auto& temporaryBlobPaths = m_temporaryBlobPathsByConnection.ensure(connectionID, [] {
		685	return HashSet<String> { };
		686	}).iterator->value;
		687	temporaryBlobPaths.add(filePaths.begin(), filePaths.end());
		688	});
		689	}
		690
		691	void NetworkStorageManager::requestSpace(const WebCore::ClientOrigin& origin, uint64_t size, CompletionHandler<void(bool)>&& completionHandler)
		692	{
		693	ASSERT(RunLoop::isMain());
		694
		695	m_queue->dispatch([this, protectedThis = Ref { *this }, origin = crossThreadCopy(origin), size, completionHandler = WTFMove(completionHandler)]() mutable {
		696	localOriginStorageManager(origin).quotaManager().requestSpace(size, [completionHandler = WTFMove(completionHandler)](auto decision) mutable {
		697	RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), decision]() mutable {
		698	completionHandler(decision == QuotaManager::Decision::Grant);
		699	});
		700	});
		701	});
		702	}
		703
		704	void NetworkStorageManager::resetQuotaForTesting(CompletionHandler<void()>&& completionHandler)
		705	{
		706	ASSERT(RunLoop::isMain());
		707
		708	m_queue->dispatch([this, protectedThis = Ref { *this }, completionHandler = WTFMove(completionHandler)]() mutable {
		709	for (auto& manager : m_localOriginStorageManagers.values())
		710	manager->quotaManager().resetQuotaForTesting();
		711	RunLoop::main().dispatch(WTFMove(completionHandler));
		712	});
		713	}
		714
		715	void NetworkStorageManager::resetQuotaUpdatedBasedOnUsageForTesting(const WebCore::ClientOrigin& origin)
		716	{
		717	ASSERT(RunLoop::isMain());
		718
		719	m_queue->dispatch([this, protectedThis = Ref { *this }, origin = crossThreadCopy(origin)]() mutable {
		720	if (auto manager = m_localOriginStorageManagers.get(origin))
		721	manager->quotaManager().resetQuotaUpdatedBasedOnUsageForTesting();
		722	});
		723	}
		724
639	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)	725	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)
640	{	726	{
641	ASSERT(!RunLoop::isMain());	727	ASSERT(!RunLoop::isMain());
Lines 723-727 void NetworkStorageManager::clear(IPC::Connection& connection, StorageAreaIdenti a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp_sec11
723	completionHandler();	809	completionHandler();
724	}	810	}
725		811
		812	void NetworkStorageManager::openDatabase(IPC::Connection& connection, const WebCore::IDBRequestData& requestData)
		813	{
		814	auto& connectionToClient = m_idbStorageRegistry->getOrCreateConnectionToClient(connection.uniqueID(), requestData.requestIdentifier().connectionIdentifier());
		815	localOriginStorageManager(requestData.databaseIdentifier().origin()).idbStorageManager(*m_idbStorageRegistry).openDatabase(connectionToClient, requestData);
		816	}
		817
		818	void NetworkStorageManager::openDBRequestCancelled(const WebCore::IDBRequestData& requestData)
		819	{
		820	localOriginStorageManager(requestData.databaseIdentifier().origin()).idbStorageManager(*m_idbStorageRegistry).openDBRequestCancelled(requestData);
		821	}
		822
		823	void NetworkStorageManager::deleteDatabase(IPC::Connection& connection, const WebCore::IDBRequestData& requestData)
		824	{
		825	auto& connectionToClient = m_idbStorageRegistry->getOrCreateConnectionToClient(connection.uniqueID(), requestData.requestIdentifier().connectionIdentifier());
		826	localOriginStorageManager(requestData.databaseIdentifier().origin()).idbStorageManager(*m_idbStorageRegistry).deleteDatabase(connectionToClient, requestData);
		827	}
		828
		829	void NetworkStorageManager::establishTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBTransactionInfo& transactionInfo)
		830	{
		831	if (auto connection = m_idbStorageRegistry->getConnection(databaseConnectionIdentifier))
		832	connection->establishTransaction(transactionInfo);
		833	}
		834
		835	void NetworkStorageManager::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
		836	{
		837	if (auto connection = m_idbStorageRegistry->getConnection(databaseConnectionIdentifier))
		838	connection->connectionPendingCloseFromClient();
		839	}
		840
		841	void NetworkStorageManager::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
		842	{
		843	if (auto connection = m_idbStorageRegistry->getConnection(databaseConnectionIdentifier))
		844	connection->connectionClosedFromClient();
		845	}
		846
		847	void NetworkStorageManager::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier)
		848	{
		849	if (auto transaction = m_idbStorageRegistry->getTransaction(transactionIdentifier))
		850	transaction->abortWithoutCallback();
		851
		852	if (auto connection = m_idbStorageRegistry->getConnection(databaseConnectionIdentifier))
		853	connection->connectionClosedFromClient();
		854	}
		855
		856	void NetworkStorageManager::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier, const WebCore::IndexedDB::ConnectionClosedOnBehalfOfServer connectionClosed)
		857	{
		858	if (auto connection = m_idbStorageRegistry->getConnection(databaseConnectionIdentifier))
		859	connection->didFireVersionChangeEvent(requestIdentifier, connectionClosed);
		860	}
		861
		862	void NetworkStorageManager::abortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier)
		863	{
		864	if (auto transaction = m_idbStorageRegistry->getTransaction(transactionIdentifier))
		865	transaction->abort();
		866	}
		867
		868	void NetworkStorageManager::commitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, uint64_t pendingRequestCount)
		869	{
		870	if (auto transaction = m_idbStorageRegistry->getTransaction(transactionIdentifier))
		871	transaction->commit(pendingRequestCount);
		872	}
		873
		874	void NetworkStorageManager::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier)
		875	{
876	if (auto connection = m_idbStorageRegistry->getConnection(databaseConnectionIdentifier))
877	connection->didFinishHandlingVersionChange(transactionIdentifier);
878	}
879
880	void NetworkStorageManager::createObjectStore(const WebCore::IDBRequestData& requestData, const WebCore::IDBObjectStoreInfo& objectStoreInfo)
881	{
882	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier())) {
883	ASSERT(transaction->isVersionChange());
884	transaction->createObjectStore(requestData, objectStoreInfo);
885	}
886	}
887
888	void NetworkStorageManager::deleteObjectStore(const WebCore::IDBRequestData& requestData, const String& objectStoreName)
889	{
890	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier())) {
891	ASSERT(transaction->isVersionChange());
892	transaction->deleteObjectStore(requestData, objectStoreName);
893	}
894	}
895
896	void NetworkStorageManager::renameObjectStore(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& newName)
897	{
898	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier())) {
899	ASSERT(transaction->isVersionChange());
900	transaction->renameObjectStore(requestData, objectStoreIdentifier, newName);
901	}
902	}
903
904	void NetworkStorageManager::clearObjectStore(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier)
905	{
906	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
907	transaction->clearObjectStore(requestData, objectStoreIdentifier);
908	}
909
910	void NetworkStorageManager::createIndex(const WebCore::IDBRequestData& requestData, const WebCore::IDBIndexInfo& indexInfo)
911	{
912	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
913	transaction->createIndex(requestData, indexInfo);
914	}
915
916	void NetworkStorageManager::deleteIndex(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
917	{
918	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
919	transaction->deleteIndex(requestData, objectStoreIdentifier, indexName);
920	}
921
922	void NetworkStorageManager::renameIndex(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
923	{
924	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
925	transaction->renameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName);
926	}
927
928	void NetworkStorageManager::putOrAdd(IPC::Connection& connection, const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyData& keyData, const WebCore::IDBValue& value, WebCore::IndexedDB::ObjectStoreOverwriteMode overwriteMode)
929	{
930	if (value.blobURLs().size() != value.blobFilePaths().size()) {
931	RELEASE_LOG_FAULT(IndexedDB, "NetworkStorageManager::putOrAdd: Number of blob URLs doesn't match the number of blob file paths.");
932	ASSERT_NOT_REACHED();
933	return;
934	}
935
936	// Validate temporary blob paths in \|value\| to make sure they belong to the source process.
937	if (!value.blobFilePaths().isEmpty()) {
938	auto it = m_temporaryBlobPathsByConnection.find(connection.uniqueID());
939	if (it == m_temporaryBlobPathsByConnection.end()) {
940	RELEASE_LOG_FAULT(IndexedDB, "NetworkStorageManager::putOrAdd: IDBValue contains blob paths but none are allowed for this process");
941	ASSERT_NOT_REACHED();
942	return;
943	}
944
945	auto& temporaryBlobPathsForConnection = it->value;
946	for (auto& blobFilePath : value.blobFilePaths()) {
947	if (!temporaryBlobPathsForConnection.remove(blobFilePath)) {
948	RELEASE_LOG_FAULT(IndexedDB, "NetworkStorageManager::putOrAdd: Blob path was not created for this WebProcess");
949	ASSERT_NOT_REACHED();
950	return;
951	}
952	}
953	}
954
955	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
956	transaction->putOrAdd(requestData, keyData, value, overwriteMode);
957	}
958
959	void NetworkStorageManager::getRecord(const WebCore::IDBRequestData& requestData, const WebCore::IDBGetRecordData& getRecordData)
960	{
961	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
962	transaction->getRecord(requestData, getRecordData);
963	}
964
965	void NetworkStorageManager::getAllRecords(const WebCore::IDBRequestData& requestData, const WebCore::IDBGetAllRecordsData& getAllRecordsData)
966	{
967	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
968	transaction->getAllRecords(requestData, getAllRecordsData);
969	}
970
971	void NetworkStorageManager::getCount(const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyRangeData& keyRangeData)
972	{
973	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
974	transaction->getCount(requestData, keyRangeData);
975	}
976
977	void NetworkStorageManager::deleteRecord(const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyRangeData& keyRangeData)
978	{
979	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
980	transaction->deleteRecord(requestData, keyRangeData);
981	}
982
983	void NetworkStorageManager::openCursor(const WebCore::IDBRequestData& requestData, const WebCore::IDBCursorInfo& cursorInfo)
984	{
985	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
986	transaction->openCursor(requestData, cursorInfo);
987	}
988
989	void NetworkStorageManager::iterateCursor(const WebCore::IDBRequestData& requestData, const WebCore::IDBIterateCursorData& cursorData)
990	{
991	if (auto transaction = m_idbStorageRegistry->getTransaction(requestData.transactionIdentifier()))
992	transaction->iterateCursor(requestData, cursorData);
993	}
994
995	void NetworkStorageManager::getAllDatabaseNamesAndVersions(IPC::Connection& connection, const WebCore::IDBResourceIdentifier& requestIdentifier, const WebCore::ClientOrigin& origin)
996	{
997	auto& connectionToClient = m_idbStorageRegistry->getOrCreateConnectionToClient(connection.uniqueID(), requestIdentifier.connectionIdentifier());
998	auto result = localOriginStorageManager(origin).idbStorageManager(*m_idbStorageRegistry).getAllDatabaseNamesAndVersions();
999	connectionToClient.didGetAllDatabaseNamesAndVersions(requestIdentifier, WTFMove(result));
1000	}
1001
726	} // namespace WebKit	1002	} // namespace WebKit
727		1003

Lines 36-41 a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec1
- a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h -2 / +57 lines
36	#include <WebCore/ClientOrigin.h>	36	#include <WebCore/ClientOrigin.h>
37	#include <WebCore/FileSystemHandleIdentifier.h>	37	#include <WebCore/FileSystemHandleIdentifier.h>
38	#include <WebCore/FileSystemSyncAccessHandleIdentifier.h>	38	#include <WebCore/FileSystemSyncAccessHandleIdentifier.h>
		39	#include <WebCore/IDBResourceIdentifier.h>
		40	#include <WebCore/IndexedDB.h>
39	#include <pal/SessionID.h>	41	#include <pal/SessionID.h>
40	#include <wtf/Forward.h>	42	#include <wtf/Forward.h>
41		43
Lines 44-61 class SharedFileHandle; a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec2
44	}	46	}
45		47
46	namespace WebCore {	48	namespace WebCore {
		49	class IDBCursorInfo;
		50	class IDBKeyData;
		51	class IDBIndexInfo;
		52	class IDBObjectStoreInfo;
		53	class IDBRequestData;
		54	class IDBTransactionInfo;
		55	class IDBValue;
47	struct ClientOrigin;	56	struct ClientOrigin;
		57	struct IDBGetAllRecordsData;
		58	struct IDBGetRecordData;
		59	struct IDBGetAllRecordsData;
		60	struct IDBIterateCursorData;
		61	struct IDBKeyRangeData;
48	enum class StorageType : uint8_t;	62	enum class StorageType : uint8_t;
49	}	63	}
50		64
51	namespace WebKit {	65	namespace WebKit {
52		66
53	class FileSystemStorageHandleRegistry;	67	class FileSystemStorageHandleRegistry;
		68	class IDBStorageRegistry;
54	class StorageAreaRegistry;	69	class StorageAreaRegistry;
55		70
56	class NetworkStorageManager final : public IPC::Connection::WorkQueueMessageReceiver {	71	class NetworkStorageManager final : public IPC::Connection::WorkQueueMessageReceiver {
57	public:	72	public:
58	static Ref<NetworkStorageManager> create(PAL::SessionID, const String& path, const String& customLocalStoragePath);	73	static Ref<NetworkStorageManager> create(PAL::SessionID, IPC::Connection::UniqueID, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyOriginQuota);
59	static bool canHandleTypes(OptionSet<WebsiteDataType>);	74	static bool canHandleTypes(OptionSet<WebsiteDataType>);
60		75
61	void startReceivingMessageFromConnection(IPC::Connection&);	76	void startReceivingMessageFromConnection(IPC::Connection&);
Lines 64-69 public: a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec3
64	PAL::SessionID sessionID() const { return m_sessionID; }	79	PAL::SessionID sessionID() const { return m_sessionID; }
65	void close();	80	void close();
66	void clearStorageForTesting(CompletionHandler<void()>&&);	81	void clearStorageForTesting(CompletionHandler<void()>&&);
		82	void didIncreaseQuota(const WebCore::ClientOrigin&, QuotaIncreaseRequestIdentifier, std::optional<uint64_t> newQuota);
67	void fetchData(OptionSet<WebsiteDataType>, CompletionHandler<void(Vector<WebsiteData::Entry>&&)>&&);	83	void fetchData(OptionSet<WebsiteDataType>, CompletionHandler<void(Vector<WebsiteData::Entry>&&)>&&);
68	void deleteData(OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, CompletionHandler<void()>&&);	84	void deleteData(OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, CompletionHandler<void()>&&);
69	void deleteDataModifiedSince(OptionSet<WebsiteDataType>, WallTime, CompletionHandler<void()>&&);	85	void deleteDataModifiedSince(OptionSet<WebsiteDataType>, WallTime, CompletionHandler<void()>&&);
Lines 73-86 public: a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec4
73	void resume();	89	void resume();
74	void handleLowMemoryWarning();	90	void handleLowMemoryWarning();
75	void syncLocalStorage(CompletionHandler<void()>&&);	91	void syncLocalStorage(CompletionHandler<void()>&&);
		92	void registerTemporaryBlobFilePaths(IPC::Connection&, const Vector<String>&);
		93	void requestSpace(const WebCore::ClientOrigin&, uint64_t size, CompletionHandler<void(bool)>&&);
		94	void resetQuotaForTesting(CompletionHandler<void()>&&);
		95	void resetQuotaUpdatedBasedOnUsageForTesting(const WebCore::ClientOrigin&);
76		96
77	private:	97	private:
78	NetworkStorageManager(PAL::SessionID, const String& path, const String& customLocalStoragePath);	98	NetworkStorageManager(PAL::SessionID, const String& path, const String& customLocalStoragePath);
		99	NetworkStorageManager(PAL::SessionID, IPC::Connection::UniqueID, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyOriginQuota);
79	~NetworkStorageManager();	100	~NetworkStorageManager();
80	OriginStorageManager& localOriginStorageManager(const WebCore::ClientOrigin&);	101	OriginStorageManager& localOriginStorageManager(const WebCore::ClientOrigin&);
81	bool removeOriginStorageManagerIfPossible(const WebCore::ClientOrigin&);	102	bool removeOriginStorageManagerIfPossible(const WebCore::ClientOrigin&);
82	void deleteOriginDirectoryIfPossible(const WebCore::ClientOrigin&);	103	void deleteOriginDirectoryIfPossible(const WebCore::ClientOrigin&);
83	FileSystemStorageHandleRegistry& fileSystemStorageHandleRegistry();
84		104
85	void forEachOriginDirectory(const Function<void(const String&)>&);	105	void forEachOriginDirectory(const Function<void(const String&)>&);
86	HashSet<WebCore::ClientOrigin> getAllOrigins();	106	HashSet<WebCore::ClientOrigin> getAllOrigins();
Lines 118-123 private: a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec5
118	void removeItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, String&& key, String&& urlString, CompletionHandler<void()>&&);	138	void removeItem(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, String&& key, String&& urlString, CompletionHandler<void()>&&);
119	void clear(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, String&& urlString, CompletionHandler<void()>&&);	139	void clear(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, String&& urlString, CompletionHandler<void()>&&);
120		140
		141	// Message handlers for IndexedDB.
		142	void openDatabase(IPC::Connection&, const WebCore::IDBRequestData&);
		143	void openDBRequestCancelled(const WebCore::IDBRequestData&);
		144	void deleteDatabase(IPC::Connection&, const WebCore::IDBRequestData&);
		145	void establishTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBTransactionInfo&);
		146	void databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier);
		147	void databaseConnectionClosed(uint64_t databaseConnectionIdentifier);
		148	void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier);
		149	void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier, const WebCore::IndexedDB::ConnectionClosedOnBehalfOfServer);
		150	void abortTransaction(const WebCore::IDBResourceIdentifier&);
		151	void commitTransaction(const WebCore::IDBResourceIdentifier&, uint64_t pendingRequestCount);
		152	void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier&);
		153	void createObjectStore(const WebCore::IDBRequestData&, const WebCore::IDBObjectStoreInfo&);
		154	void deleteObjectStore(const WebCore::IDBRequestData&, const String& objectStoreName);
		155	void renameObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);
		156	void clearObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier);
		157	void createIndex(const WebCore::IDBRequestData&, const WebCore::IDBIndexInfo&);
		158	void deleteIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);
		159	void renameIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);
		160	void putOrAdd(IPC::Connection&, const WebCore::IDBRequestData&, const WebCore::IDBKeyData&, const WebCore::IDBValue&, WebCore::IndexedDB::ObjectStoreOverwriteMode);
		161	void getRecord(const WebCore::IDBRequestData&, const WebCore::IDBGetRecordData&);
		162	void getAllRecords(const WebCore::IDBRequestData&, const WebCore::IDBGetAllRecordsData&);
		163	void getCount(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&);
		164	void deleteRecord(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&);
		165	void openCursor(const WebCore::IDBRequestData&, const WebCore::IDBCursorInfo&);
		166	void iterateCursor(const WebCore::IDBRequestData&, const WebCore::IDBIterateCursorData&);
		167	void getAllDatabaseNamesAndVersions(IPC::Connection&, const WebCore::IDBResourceIdentifier&, const WebCore::ClientOrigin&);
		168
121	PAL::SessionID m_sessionID;	169	PAL::SessionID m_sessionID;
122	Ref<SuspendableWorkQueue> m_queue;	170	Ref<SuspendableWorkQueue> m_queue;
123	String m_path;	171	String m_path;
Lines 127-133 private: a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h_sec6
127	WeakHashSet<IPC::Connection> m_connections; // Main thread only.	175	WeakHashSet<IPC::Connection> m_connections; // Main thread only.
128	std::unique_ptr<FileSystemStorageHandleRegistry> m_fileSystemStorageHandleRegistry;	176	std::unique_ptr<FileSystemStorageHandleRegistry> m_fileSystemStorageHandleRegistry;
129	std::unique_ptr<StorageAreaRegistry> m_storageAreaRegistry;	177	std::unique_ptr<StorageAreaRegistry> m_storageAreaRegistry;
		178	std::unique_ptr<IDBStorageRegistry> m_idbStorageRegistry;
130	String m_customLocalStoragePath;	179	String m_customLocalStoragePath;
		180	String m_customIDBStoragePath;
		181	String m_customCacheStoragePath;
		182	uint64_t m_defaultOriginQuota;
		183	uint64_t m_defaultThirdPartyOriginQuota;
		184	IPC::Connection::UniqueID m_parentConnection;
		185	HashMap<IPC::Connection::UniqueID, HashSet<String>> m_temporaryBlobPathsByConnection;
131	};	186	};
132		187
133	} // namespace WebKit	188	} // namespace WebKit



    SetItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String key, String value, String urlString) -> (bool quotaException) Async WantsConnection
    RemoveItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String key, String urlString) -> () Async WantsConnection
    Clear(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String urlString) -> () Async WantsConnection

    OpenDatabase(WebCore::IDBRequestData requestData) WantsConnection
    OpenDBRequestCancelled(WebCore::IDBRequestData requestData)
    DeleteDatabase(WebCore::IDBRequestData requestData) WantsConnection
    EstablishTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBTransactionInfo info)
    DatabaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
    DatabaseConnectionClosed(uint64_t databaseConnectionIdentifier)
    AbortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier)
    DidFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier requestIdentifier, WebCore::IndexedDB::ConnectionClosedOnBehalfOfServer connectionClosedOnBehalfOfServer)
    DidFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier)
    AbortTransaction(WebCore::IDBResourceIdentifier transactionIdentifier)
    CommitTransaction(WebCore::IDBResourceIdentifier transactionIdentifier, uint64_t pendingRequestCount)
    CreateObjectStore(WebCore::IDBRequestData requestData, WebCore::IDBObjectStoreInfo info)
    DeleteObjectStore(WebCore::IDBRequestData requestData, String objectStoreName)
    RenameObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String newName)
    ClearObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier)
    CreateIndex(WebCore::IDBRequestData requestData, WebCore::IDBIndexInfo info)
    DeleteIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String indexName)
    RenameIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, String newName)
    PutOrAdd(WebCore::IDBRequestData requestData, WebCore::IDBKeyData key, WebCore::IDBValue value, WebCore::IndexedDB::ObjectStoreOverwriteMode overwriteMode) WantsConnection
    GetRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBGetRecordData getRecordData)
    GetAllRecords(WebCore::IDBRequestData requestData, struct WebCore::IDBGetAllRecordsData getAllRecordsData)
    GetCount(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range)
    DeleteRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range)
    OpenCursor(WebCore::IDBRequestData requestData, WebCore::IDBCursorInfo info)
    IterateCursor(WebCore::IDBRequestData requestData, struct WebCore::IDBIterateCursorData data)
    GetAllDatabaseNamesAndVersions(WebCore::IDBResourceIdentifier requestIdentifier, struct WebCore::ClientOrigin origin) WantsConnection
}

Lines 26-33 a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec1
- a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp -8 / +93 lines
26	#include "config.h"	26	#include "config.h"
27	#include "OriginStorageManager.h"	27	#include "OriginStorageManager.h"
28		28
		29	#include "CacheStorageEngine.h"
29	#include "FileSystemStorageHandleRegistry.h"	30	#include "FileSystemStorageHandleRegistry.h"
30	#include "FileSystemStorageManager.h"	31	#include "FileSystemStorageManager.h"
		32	#include "IDBStorageManager.h"
		33	#include "IDBStorageRegistry.h"
31	#include "LocalStorageManager.h"	34	#include "LocalStorageManager.h"
32	#include "MemoryStorageArea.h"	35	#include "MemoryStorageArea.h"
33	#include "SessionStorageManager.h"	36	#include "SessionStorageManager.h"
Lines 44-53 enum class OriginStorageManager::StorageBucketMode : bool { BestEffort, Persiste a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec2
44	class OriginStorageManager::StorageBucket {	47	class OriginStorageManager::StorageBucket {
45	WTF_MAKE_FAST_ALLOCATED;	48	WTF_MAKE_FAST_ALLOCATED;
46	public:	49	public:
47	StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath)	50	StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath, const String& idbStoragePath)
48	: m_rootPath(rootPath)	51	: m_rootPath(rootPath)
49	, m_identifier(identifier)	52	, m_identifier(identifier)
50	, m_localStoragePath(localStoragePath)	53	, m_localStoragePath(localStoragePath)
		54	, m_idbStoragePath(idbStoragePath)
51	{	55	{
52	}	56	}
53		57
Lines 70-75 public: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec3
70	FileSystem,	74	FileSystem,
71	LocalStorage,	75	LocalStorage,
72	SessionStorage,	76	SessionStorage,
		77	IndexedDB,
73	};	78	};
74		79
75	static std::optional<WebsiteDataType> toWebsiteDataType(const String& storageIdentifier)	80	static std::optional<WebsiteDataType> toWebsiteDataType(const String& storageIdentifier)
Lines 80-85 public: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec4
80	return WebsiteDataType::LocalStorage;	85	return WebsiteDataType::LocalStorage;
81	if (storageIdentifier == "SessionStorage"_s)	86	if (storageIdentifier == "SessionStorage"_s)
82	return WebsiteDataType::SessionStorage;	87	return WebsiteDataType::SessionStorage;
		88	if (storageIdentifier == "IndexedDB"_s)
		89	return WebsiteDataType::IndexedDBDatabases;
83		90
84	return std::nullopt;	91	return std::nullopt;
85	}	92	}
Lines 93-98 public: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec5
93	return "LocalStorage"_s;	100	return "LocalStorage"_s;
94	case StorageType::SessionStorage:	101	case StorageType::SessionStorage:
95	return "SessionStorage"_s;	102	return "SessionStorage"_s;
		103	case StorageType::IndexedDB:
		104	return "IndexedDB"_s;
96	default:	105	default:
97	break;	106	break;
98	}	107	}
Lines 143-155 public: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec6
143	return m_sessionStorageManager.get();	152	return m_sessionStorageManager.get();
144	}	153	}
145		154
		155	IDBStorageManager& idbStorageManager(IDBStorageRegistry& registry, IDBStorageManager::QuotaCheckFunction&& quotaCheckFunction)
		156	{
		157	if (!m_idbStorageManager)
		158	m_idbStorageManager = makeUnique<IDBStorageManager>(m_idbStoragePath, registry, WTFMove(quotaCheckFunction));
		159
		160	return *m_idbStorageManager;
		161	}
		162
		163	IDBStorageManager* existingIDBStorageManager()
		164	{
		165	return m_idbStorageManager.get();
		166	}
		167
146	bool isActive() const	168	bool isActive() const
147	{	169	{
148	// We cannot remove the bucket if it has in-memory data, otherwise session	170	// We cannot remove the bucket if it has in-memory data, otherwise session
149	// data may be lost.	171	// data may be lost.
150	return (m_fileSystemStorageManager && m_fileSystemStorageManager->isActive())	172	return (m_fileSystemStorageManager && m_fileSystemStorageManager->isActive())
151	\|\| (m_localStorageManager && (m_localStorageManager->hasDataInMemory() \|\| m_localStorageManager->isActive()))	173	\|\| (m_localStorageManager && (m_localStorageManager->hasDataInMemory() \|\| m_localStorageManager->isActive()))
152	\|\| (m_sessionStorageManager && (m_sessionStorageManager->hasDataInMemory() \|\| m_sessionStorageManager->isActive()));	174	\|\| (m_sessionStorageManager && (m_sessionStorageManager->hasDataInMemory() \|\| m_sessionStorageManager->isActive()))
		175	\|\| (m_idbStorageManager && (m_idbStorageManager->hasDataInMemory() \|\| m_idbStorageManager->isActive()));
153	}	176	}
154		177
155	bool isEmpty() const	178	bool isEmpty() const
Lines 165-171 public: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec7
165	if (hasValidFile)	188	if (hasValidFile)
166	return false;	189	return false;
167		190
168	return !FileSystem::fileExists(m_localStoragePath);	191	FileSystem::deleteEmptyDirectory(m_idbStoragePath);
		192	return !FileSystem::fileExists(m_localStoragePath) && !FileSystem::fileExists(m_idbStoragePath);
169	}	193	}
170		194
171	OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType> types)	195	OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType> types)
Lines 186-194 public: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec8
186		210
187	if (types.contains(WebsiteDataType::SessionStorage) && modifiedSinceTime < WallTime::now())	211	if (types.contains(WebsiteDataType::SessionStorage) && modifiedSinceTime < WallTime::now())
188	deleteSessionStorageData();	212	deleteSessionStorageData();
		213
		214	if (types.contains(WebsiteDataType::IndexedDBDatabases))
		215	deleteIDBStorageData(modifiedSinceTime);
189	}	216	}
190		217
191	void moveData(const String& path, const String& localStoragePath)	218	void moveData(const String& path, const String& localStoragePath, const String& idbStoragePath)
192	{	219	{
193	m_fileSystemStorageManager = nullptr;	220	m_fileSystemStorageManager = nullptr;
194	if (m_localStorageManager)	221	if (m_localStorageManager)
Lines 201-206 public: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec9
201	FileSystem::makeAllDirectories(FileSystem::parentPath(localStoragePath));	228	FileSystem::makeAllDirectories(FileSystem::parentPath(localStoragePath));
202	WebCore::SQLiteFileSystem::moveDatabaseFile(m_localStoragePath, localStoragePath);	229	WebCore::SQLiteFileSystem::moveDatabaseFile(m_localStoragePath, localStoragePath);
203	}	230	}
		231
		232	if (!m_idbStoragePath.isEmpty() && !idbStoragePath.isEmpty()) {
		233	FileSystem::makeAllDirectories(FileSystem::parentPath(idbStoragePath));
		234	WebCore::SQLiteFileSystem::moveDatabaseFile(m_idbStoragePath, idbStoragePath);
		235	}
204	}	236	}
205		237
206	private:	238	private:
Lines 217-222 private: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec10
217	result.add(WebsiteDataType::SessionStorage);	249	result.add(WebsiteDataType::SessionStorage);
218	}	250	}
219		251
		252	if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
		253	if (m_idbStorageManager && m_idbStorageManager->hasDataInMemory())
		254	result.add(WebsiteDataType::IndexedDBDatabases);
		255	}
		256
220	return result;	257	return result;
221	}	258	}
222		259
Lines 233-238 private: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec11
233	result.add(WebsiteDataType::LocalStorage);	270	result.add(WebsiteDataType::LocalStorage);
234	}	271	}
235		272
		273	if (types.contains(WebsiteDataType::IndexedDBDatabases) && !result.contains(WebsiteDataType::IndexedDBDatabases)) {
		274	if (auto databases = FileSystem::listDirectory(m_idbStoragePath); !databases.isEmpty())
		275	result.add(WebsiteDataType::IndexedDBDatabases);
		276	}
		277
236	return result;	278	return result;
237	}	279	}
238		280
Lines 270-275 private: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec12
270	m_sessionStorageManager = nullptr;	312	m_sessionStorageManager = nullptr;
271	}	313	}
272		314
		315	void deleteIDBStorageData(WallTime time)
		316	{
		317	if (m_idbStorageManager)
		318	m_idbStorageManager->closeDatabasesForDeletion();
		319
		320	FileSystem::deleteAllFilesModifiedSince(m_idbStoragePath, time);
		321	}
		322
273	String m_rootPath;	323	String m_rootPath;
274	String m_identifier;	324	String m_identifier;
275	StorageBucketMode m_mode { StorageBucketMode::BestEffort };	325	StorageBucketMode m_mode { StorageBucketMode::BestEffort };
Lines 277-287 private: a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec13
277	std::unique_ptr<LocalStorageManager> m_localStorageManager;	327	std::unique_ptr<LocalStorageManager> m_localStorageManager;
278	String m_localStoragePath;	328	String m_localStoragePath;
279	std::unique_ptr<SessionStorageManager> m_sessionStorageManager;	329	std::unique_ptr<SessionStorageManager> m_sessionStorageManager;
		330	std::unique_ptr<IDBStorageManager> m_idbStorageManager;
		331	String m_idbStoragePath;
280	};	332	};
281		333
282	OriginStorageManager::OriginStorageManager(String&& path, String&& localStoragePath)	334	static Ref<QuotaManager> createQuotaManager(uint64_t quota, const String& idbStoragePath, const String& cacheStoragePath, QuotaManager::IncreaseQuotaFunction&& increaseQuotaFunction)
		335	{
		336	QuotaManager::GetUsageFunction getUsageFunction = [idbStoragePath, cacheStoragePath]() {
		337	return IDBStorageManager::idbStorageSize(idbStoragePath) + CacheStorage::Engine::diskUsage(cacheStoragePath);
		338	};
		339	return QuotaManager::create(quota, WTFMove(getUsageFunction), WTFMove(increaseQuotaFunction));
		340	}
		341
		342	OriginStorageManager::OriginStorageManager(uint64_t quota, QuotaManager::IncreaseQuotaFunction&& increaseQuotaFunction, String&& path, String&& localStoragePath, String&& idbStoragePath, String&& cacheStoragePath)
283	: m_path(WTFMove(path))	343	: m_path(WTFMove(path))
284	, m_localStoragePath(WTFMove(localStoragePath))	344	, m_localStoragePath(WTFMove(localStoragePath))
		345	, m_idbStoragePath(WTFMove(idbStoragePath))
		346	, m_cacheStoragePath(WTFMove(cacheStoragePath))
		347	, m_quotaManager(createQuotaManager(quota, m_idbStoragePath, m_cacheStoragePath, WTFMove(increaseQuotaFunction)))
285	{	348	{
286	ASSERT(!RunLoop::isMain());	349	ASSERT(!RunLoop::isMain());
287	}	350	}
Lines 297-307 void OriginStorageManager::connectionClosed(IPC::Connection::UniqueID connection a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec14
297	OriginStorageManager::StorageBucket& OriginStorageManager::defaultBucket()	360	OriginStorageManager::StorageBucket& OriginStorageManager::defaultBucket()
298	{	361	{
299	if (!m_defaultBucket)	362	if (!m_defaultBucket)
300	m_defaultBucket = makeUnique<StorageBucket>(m_path, "default"_s, m_localStoragePath);	363	m_defaultBucket = makeUnique<StorageBucket>(m_path, "default"_s, m_localStoragePath, m_idbStoragePath);
301		364
302	return *m_defaultBucket;	365	return *m_defaultBucket;
303	}	366	}
304		367
		368	QuotaManager& OriginStorageManager::quotaManager()
		369	{
		370	return m_quotaManager.get();
		371	}
		372
305	FileSystemStorageManager& OriginStorageManager::fileSystemStorageManager(FileSystemStorageHandleRegistry& registry)	373	FileSystemStorageManager& OriginStorageManager::fileSystemStorageManager(FileSystemStorageHandleRegistry& registry)
306	{	374	{
307	return defaultBucket().fileSystemStorageManager(registry);	375	return defaultBucket().fileSystemStorageManager(registry);
Lines 327-332 SessionStorageManager* OriginStorageManager::existingSessionStorageManager() a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec15
327	return defaultBucket().existingSessionStorageManager();	395	return defaultBucket().existingSessionStorageManager();
328	}	396	}
329		397
		398	IDBStorageManager& OriginStorageManager::idbStorageManager(IDBStorageRegistry& registry)
		399	{
		400	return defaultBucket().idbStorageManager(registry, [quotaManager = WeakPtr { this->quotaManager() }](uint64_t spaceRequested, CompletionHandler<void(bool)>&& completionHandler) mutable {
		401	if (!quotaManager)
		402	return completionHandler(false);
		403
		404	quotaManager->requestSpace(spaceRequested, [completionHandler = WTFMove(completionHandler)](auto decision) mutable {
		405	completionHandler(decision == QuotaManager::Decision::Grant);
		406	});
		407	});
		408	}
		409
		410	IDBStorageManager* OriginStorageManager::existingIDBStorageManager()
		411	{
		412	return defaultBucket().existingIDBStorageManager();
		413	}
		414
330	bool OriginStorageManager::isActive()	415	bool OriginStorageManager::isActive()
331	{	416	{
332	return defaultBucket().isActive();	417	return defaultBucket().isActive();
Lines 359-369 void OriginStorageManager::deleteData(OptionSet<WebsiteDataType> types, WallTime a/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp_sec16
359	defaultBucket().deleteData(types, modifiedSince);	444	defaultBucket().deleteData(types, modifiedSince);
360	}	445	}
361		446
362	void OriginStorageManager::moveData(const String& newPath, const String& localStoragePath)	447	void OriginStorageManager::moveData(const String& newPath, const String& localStoragePath, const String& idbStoragePath)
363	{	448	{
364	ASSERT(!RunLoop::isMain());	449	ASSERT(!RunLoop::isMain());
365		450
366	defaultBucket().moveData(newPath, localStoragePath);	451	defaultBucket().moveData(newPath, localStoragePath, idbStoragePath);
367	}	452	}
368		453
369	} // namespace WebKit	454	} // namespace WebKit



#pragma once

#include "Connection.h"
#include "QuotaManager.h"
#include <wtf/text/WTFString.h>

namespace WebCore {
struct ClientOrigin;
}

namespace WebKit {

class FileSystemStorageHandleRegistry;
class FileSystemStorageManager;
class IDBStorageManager;
class IDBStorageRegistry;
class LocalStorageManager;
class SessionStorageManager;
class StorageAreaRegistry;

class OriginStorageManager {
    WTF_MAKE_FAST_ALLOCATED;
public:
    OriginStorageManager(uint64_t quota, QuotaManager::IncreaseQuotaFunction&&, String&& path, String&& localStoragePath, String&& idbStoragePath, String&& cacheStoragePath);
    ~OriginStorageManager();

    void connectionClosed(IPC::Connection::UniqueID);
    bool persisted() const { return m_persisted; }
    void setPersisted(bool value);
    QuotaManager& quotaManager();
    FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry&);
    LocalStorageManager& localStorageManager(StorageAreaRegistry&);
    LocalStorageManager* existingLocalStorageManager();
    SessionStorageManager& sessionStorageManager(StorageAreaRegistry&);
    SessionStorageManager* existingSessionStorageManager();
    IDBStorageManager& idbStorageManager(IDBStorageRegistry&);
    IDBStorageManager* existingIDBStorageManager();
    bool isActive();
    bool isEmpty();
    OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType>);
    void deleteData(OptionSet<WebsiteDataType>, WallTime);
    void moveData(const String& newPath, const String& localStoragePath, const String& idbStoragePath);

private:
    enum class StorageBucketMode : bool;
    class StorageBucket;
    StorageBucket& defaultBucket();

    void createOriginFileIfNecessary(const WebCore::ClientOrigin&);
    void deleteOriginFileIfNecessary();

    std::unique_ptr<StorageBucket> m_defaultBucket;
    String m_path;
    bool m_persisted { false };
    String m_localStoragePath;
    String m_idbStoragePath;
    String m_cacheStoragePath;
    Ref<QuotaManager> m_quotaManager;
};

} // namespace WebKit



/*
 * 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.
 */

#include "config.h"
#include "QuotaManager.h"

#include <wtf/Scope.h>

namespace WebKit {

Ref<QuotaManager> QuotaManager::create(uint64_t quota, GetUsageFunction&& getUsageFunction, IncreaseQuotaFunction&& increaseQuotaFunction)
{
    return adoptRef(*new QuotaManager(quota, WTFMove(getUsageFunction), WTFMove(increaseQuotaFunction)));
}

QuotaManager::QuotaManager(uint64_t quota, GetUsageFunction&& getUsageFunction, IncreaseQuotaFunction&& increaseQuotaFunction)
    : m_quota(quota)
    , m_initialQuota(quota)
    , m_getUsageFunction(WTFMove(getUsageFunction))
    , m_increaseQuotaFunction(WTFMove(increaseQuotaFunction))
{
    ASSERT(m_quota);
}

void QuotaManager::requestSpace(uint64_t spaceRequested, RequestCallback&& callback)
{
    m_requests.append(QuotaManager::Request { spaceRequested, WTFMove(callback), QuotaIncreaseRequestIdentifier { } });
    handleRequests();
}

void QuotaManager::handleRequests()
{
    if (m_currentRequest)
        return;

    m_isHandlingRequests = true;
    auto clearIsHandlingRequests = makeScopeExit([&] {
        m_isHandlingRequests = false;
    });

    while (!m_currentRequest && !m_requests.isEmpty()) {
        m_currentRequest = m_requests.takeFirst();
        if (grantWithCurrentQuota(m_currentRequest->spaceRequested)) {
            m_currentRequest->callback(Decision::Grant);
            m_currentRequest = std::nullopt;
            continue;
        }

        m_currentRequest->identifier = QuotaIncreaseRequestIdentifier::generateThreadSafe();
        m_increaseQuotaFunction(m_currentRequest->identifier, m_quota, *m_usage, m_currentRequest->spaceRequested);
    }
}

bool QuotaManager::grantWithCurrentQuota(uint64_t spaceRequested)
{
    if (grantFastPath(spaceRequested))
        return true;

    // When QuotaManager is used for the first time, we want to make sure its initial quota is bigger than existing disk usage,
    // based on the assumption that the quota was increased to at least the disk usage under user's permission before.
    bool shouldUpdateQuotaBasedonUsage = !m_usage;
    m_usage = m_getUsageFunction();
    if (shouldUpdateQuotaBasedonUsage) {
        auto defaultQuotaStep = m_quota / 10;
        m_quota = std::max(m_quota, defaultQuotaStep * ((*m_usage / defaultQuotaStep) + 1));
    }
    m_quotaCountdown = *m_usage < m_quota ? m_quota - *m_usage : 0;

    return grantFastPath(spaceRequested);
}

bool QuotaManager::grantFastPath(uint64_t spaceRequested)
{
    if (spaceRequested <= m_quotaCountdown) {
        m_quotaCountdown -= spaceRequested;
        return true;
    }

    return false;
}

void QuotaManager::didIncreaseQuota(QuotaIncreaseRequestIdentifier identifier, std::optional<uint64_t> newQuota)
{
    if (!m_currentRequest || m_currentRequest->identifier != identifier)
        return;

    if (newQuota) {
        m_quota = *newQuota;
        m_quotaCountdown = 0; // Recalculate m_quotaCountdown based on usage.
    }

    auto decision = grantWithCurrentQuota(m_currentRequest->spaceRequested) ? Decision::Grant : Decision::Deny;
    m_currentRequest->callback(decision);
    m_currentRequest = std::nullopt;

    if (!m_isHandlingRequests)
        handleRequests();
}

void QuotaManager::resetQuotaUpdatedBasedOnUsageForTesting()
{
    m_quota = m_initialQuota;
    m_quotaCountdown = 0;
    m_usage = std::nullopt;
}

void QuotaManager::resetQuotaForTesting()
{
    m_quota = m_initialQuota;
    m_quotaCountdown = 0;
}

} // namespace WebKit



/*
 * 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 "QuotaIncreaseRequestIdentifier.h"
#include <wtf/CompletionHandler.h>
#include <wtf/Deque.h>

namespace WebKit {

class QuotaManager : public ThreadSafeRefCounted<QuotaManager>, public CanMakeWeakPtr<QuotaManager> {
    WTF_MAKE_FAST_ALLOCATED;
public:
    using GetUsageFunction = Function<uint64_t()>;
    using IncreaseQuotaFunction = Function<void(QuotaIncreaseRequestIdentifier, uint64_t currentQuota, uint64_t currentUsage, uint64_t requestedIncrease)>;
    static Ref<QuotaManager> create(uint64_t quota, GetUsageFunction&&, IncreaseQuotaFunction&&);

    enum class Decision { Deny, Grant };
    using RequestCallback = CompletionHandler<void(Decision)>;
    void requestSpace(uint64_t spaceRequested, RequestCallback&&);
    void didIncreaseQuota(QuotaIncreaseRequestIdentifier, std::optional<uint64_t> newQuota);

    void resetQuotaUpdatedBasedOnUsageForTesting();
    void resetQuotaForTesting();

private:
    QuotaManager(uint64_t quota, GetUsageFunction&&, IncreaseQuotaFunction&&);
    void handleRequests();
    bool grantWithCurrentQuota(uint64_t spaceRequested);
    bool grantFastPath(uint64_t spaceRequested);

    struct Request {
        uint64_t spaceRequested;
        RequestCallback callback;
        QuotaIncreaseRequestIdentifier identifier;
    };
    Deque<Request> m_requests;
    std::optional<Request> m_currentRequest;
    bool m_isHandlingRequests { false };
    uint64_t m_quotaCountdown { 0 };
    uint64_t m_quota;
    uint64_t m_initialQuota; // Test only.
    std::optional<uint64_t> m_usage;
    GetUsageFunction m_getUsageFunction;
    IncreaseQuotaFunction m_increaseQuotaFunction;
};

} // namespace WebKit

Lines 287-292 def types_that_cannot_be_forward_declared(): a/Source/WebKit/Scripts/webkit/messages.py_sec1
- a/Source/WebKit/Scripts/webkit/messages.py +1 lines
287	'WebCore::NativeImageReference',	287	'WebCore::NativeImageReference',
288	'WebCore::PageIdentifier',	288	'WebCore::PageIdentifier',
289	'WebCore::PlaybackTargetClientContextIdentifier',	289	'WebCore::PlaybackTargetClientContextIdentifier',
		290	'WebKit::QuotaIncreaseRequestIdentifier',
290	'WebCore::PluginLoadClientPolicy',	291	'WebCore::PluginLoadClientPolicy',
291	'WebCore::PointerID',	292	'WebCore::PointerID',
292	'WebCore::PushSubscriptionIdentifier',	293	'WebCore::PushSubscriptionIdentifier',



/*
 * 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 QuotaIncreaseRequestIdentifierType { };
using QuotaIncreaseRequestIdentifier = ObjectIdentifier<QuotaIncreaseRequestIdentifierType>;

} // namespace WebKit



    String generalStorageDirectory;
    SandboxExtension::Handle generalStorageDirectoryHandle;

    uint64_t perOriginStorageQuota;
    uint64_t perThirdPartyOriginStorageQuota;
};

} // namespace WebKit



    });
}

void NetworkProcessProxy::increaseQuota(PAL::SessionID sessionID, const WebCore::ClientOrigin& origin, QuotaIncreaseRequestIdentifier identifier, uint64_t currentQuota, uint64_t currentUsage, uint64_t spaceRequested)
{
    requestStorageSpace(sessionID, origin, currentQuota, currentUsage, spaceRequested, [this, weakThis = WeakPtr { *this }, sessionID, origin, identifier](auto result) mutable {
        if (!weakThis)
            return;

        send(Messages::NetworkProcess::DidIncreaseQuota(sessionID, origin, identifier, result), 0);
    });
}

void NetworkProcessProxy::registerSchemeForLegacyCustomProtocol(const String& scheme)
{
#if ENABLE(LEGACY_CUSTOM_PROTOCOL_MANAGER)



#include "ProcessLauncher.h"
#include "ProcessThrottler.h"
#include "ProcessThrottlerClient.h"
#include "QuotaIncreaseRequestIdentifier.h"
#include "UserContentControllerIdentifier.h"
#include "WebProcessProxyMessagesReplies.h"
#include "WebsiteDataStore.h"

    void triggerBrowsingContextGroupSwitchForNavigation(WebPageProxyIdentifier, uint64_t navigationID, WebCore::BrowsingContextGroupSwitchDecision, const WebCore::RegistrableDomain& responseDomain, NetworkResourceLoadIdentifier existingNetworkResourceLoadIdentifierToResume, CompletionHandler<void(bool success)>&&);

    void requestStorageSpace(PAL::SessionID, const WebCore::ClientOrigin&, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(std::optional<uint64_t> quota)>&&);
    void increaseQuota(PAL::SessionID, const WebCore::ClientOrigin&, QuotaIncreaseRequestIdentifier, uint64_t currentQuota, uint64_t currentUsage, uint64_t spaceRequested);

    WebsiteDataStore* websiteDataStoreFromSessionID(PAL::SessionID);


Lines 68-73 messages -> NetworkProcessProxy LegacyReceiver { a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in_sec1
- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in +1 lines
68	#endif	68	#endif
69		69
70	RequestStorageSpace(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired) -> (std::optional<uint64_t> newQuota) Async	70	RequestStorageSpace(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired) -> (std::optional<uint64_t> newQuota) Async
		71	IncreaseQuota(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, WebKit::QuotaIncreaseRequestIdentifier identifier, uint64_t quota, uint64_t currentSize, uint64_t spaceRequested)
71		72
72	ResourceLoadDidSendRequest(WebKit::WebPageProxyIdentifier pageIdentifier, struct WebKit::ResourceLoadInfo resourceLoadInfo, WebCore::ResourceRequest request, std::optional<IPC::FormDataReference> httpBody)	73	ResourceLoadDidSendRequest(WebKit::WebPageProxyIdentifier pageIdentifier, struct WebKit::ResourceLoadInfo resourceLoadInfo, WebCore::ResourceRequest request, std::optional<IPC::FormDataReference> httpBody)
73	ResourceLoadDidPerformHTTPRedirection(WebKit::WebPageProxyIdentifier pageIdentifier, struct WebKit::ResourceLoadInfo resourceLoadInfo, WebCore::ResourceResponse resourceResponse, WebCore::ResourceRequest request)	74	ResourceLoadDidPerformHTTPRedirection(WebKit::WebPageProxyIdentifier pageIdentifier, struct WebKit::ResourceLoadInfo resourceLoadInfo, WebCore::ResourceResponse resourceResponse, WebCore::ResourceRequest request)

Lines 1716-1722 void WebsiteDataStore::dispatchOnQueue(Function<void()>&& function) a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp_sec1
- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp -1 / +1 lines
1716	uint64_t WebsiteDataStore::perThirdPartyOriginStorageQuota() const	1716	uint64_t WebsiteDataStore::perThirdPartyOriginStorageQuota() const
1717	{	1717	{
1718	// FIXME: Consider whether allowing to set a perThirdPartyOriginStorageQuota from a WebsiteDataStore.	1718	// FIXME: Consider whether allowing to set a perThirdPartyOriginStorageQuota from a WebsiteDataStore.
1719	return WebCore::StorageQuotaManager::defaultThirdPartyQuotaFromPerOriginQuota(perOriginStorageQuota());	1719	return perOriginStorageQuota() / 10;
1720	}	1720	}
1721		1721
1722	void WebsiteDataStore::setCacheModelSynchronouslyForTesting(CacheModel cacheModel)	1722	void WebsiteDataStore::setCacheModelSynchronouslyForTesting(CacheModel cacheModel)

Lines 350-355 public: a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h_sec1
- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h +1 lines
350	static WTF::String defaultDeviceIdHashSaltsStorageDirectory();	350	static WTF::String defaultDeviceIdHashSaltsStorageDirectory();
351	static WTF::String defaultJavaScriptConfigurationDirectory();	351	static WTF::String defaultJavaScriptConfigurationDirectory();
352	static bool http3Enabled();	352	static bool http3Enabled();
		353	static constexpr uint64_t defaultPerOriginQuota() { return 1000 * MB; }
353		354
354	void resetQuota(CompletionHandler<void()>&&);	355	void resetQuota(CompletionHandler<void()>&&);
355	void clearStorage(CompletionHandler<void()>&&);	356	void clearStorage(CompletionHandler<void()>&&);

Lines 33-38 namespace WebKit { a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreConfiguration.cpp_sec1
- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreConfiguration.cpp +1 lines
33		33
34	WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration(IsPersistent isPersistent, WillCopyPathsFromExistingConfiguration willCopyPaths)	34	WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration(IsPersistent isPersistent, WillCopyPathsFromExistingConfiguration willCopyPaths)
35	: m_isPersistent(isPersistent)	35	: m_isPersistent(isPersistent)
		36	, m_perOriginStorageQuota(WebsiteDataStore::defaultPerOriginQuota())
36	{	37	{
37	if (isPersistent == IsPersistent::Yes && willCopyPaths == WillCopyPathsFromExistingConfiguration::No) {	38	if (isPersistent == IsPersistent::Yes && willCopyPaths == WillCopyPathsFromExistingConfiguration::No) {
38	setApplicationCacheDirectory(WebsiteDataStore::defaultApplicationCacheDirectory());	39	setApplicationCacheDirectory(WebsiteDataStore::defaultApplicationCacheDirectory());



#pragma once

#include "APIObject.h"
#include <WebCore/StorageQuotaManager.h>
#include <wtf/URL.h>
#include <wtf/text/WTFString.h>



    String m_cacheStorageDirectory;
    String m_generalStorageDirectory;
    uint64_t m_perOriginStorageQuota;
    String m_networkCacheDirectory;
    String m_applicationCacheDirectory;
    String m_applicationCacheFlatFileSubdirectoryName { "Files"_s };

Lines 1468-1473 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec1
- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj +28 lines
1468	93B2614D227D149E00B97A76 /* StorageManager.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26149227D147200B97A76 / StorageManager.h */; };	1468	93B2614D227D149E00B97A76 /* StorageManager.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26149227D147200B97A76 / StorageManager.h */; };
1469	93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26145227D147000B97A76 / LocalStorageDatabase.h */; };	1469	93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26145227D147000B97A76 / LocalStorageDatabase.h */; };
1470	93B2614F227D14B100B97A76 /* LocalStorageDatabaseTracker.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26146227D147100B97A76 / LocalStorageDatabaseTracker.h */; };	1470	93B2614F227D14B100B97A76 /* LocalStorageDatabaseTracker.h in Headers / = {isa = PBXBuildFile; fileRef = 93B26146227D147100B97A76 / LocalStorageDatabaseTracker.h */; };
		1471	93B631E527ABA62800443A44 /* IDBStorageConnectionToClient.h in Headers / = {isa = PBXBuildFile; fileRef = 93B631E427ABA62700443A44 / IDBStorageConnectionToClient.h */; };
		1472	93B631E827ABA65D00443A44 /* IDBStorageManager.h in Headers / = {isa = PBXBuildFile; fileRef = 93B631E627ABA65C00443A44 / IDBStorageManager.h */; };
		1473	93B631ED27ABA6B400443A44 /* IDBStorageRegistry.h in Headers / = {isa = PBXBuildFile; fileRef = 93B631EB27ABA6B300443A44 / IDBStorageRegistry.h */; };
		1474	93B631F127ABACA900443A44 /* QuotaManager.h in Headers / = {isa = PBXBuildFile; fileRef = 93B631EF27ABACA900443A44 / QuotaManager.h */; };
		1475	93B631F327ABAD8000443A44 /* QuotaIncreaseRequestIdentifier.h in Headers / = {isa = PBXBuildFile; fileRef = 93B631F227ABAD7F00443A44 / QuotaIncreaseRequestIdentifier.h */; };
1471	93BDEB01171DD7AF00BFEE1B /* WKPageLoadTypesPrivate.h in Headers / = {isa = PBXBuildFile; fileRef = 93BDEB00171DD7AF00BFEE1B / WKPageLoadTypesPrivate.h */; settings = {ATTRIBUTES = (Private, ); }; };	1476	93BDEB01171DD7AF00BFEE1B /* WKPageLoadTypesPrivate.h in Headers / = {isa = PBXBuildFile; fileRef = 93BDEB00171DD7AF00BFEE1B / WKPageLoadTypesPrivate.h */; settings = {ATTRIBUTES = (Private, ); }; };
1472	93D6B772254BB5190058DD3A /* SpeechRecognitionServer.h in Headers / = {isa = PBXBuildFile; fileRef = 93D6B76C254B89580058DD3A / SpeechRecognitionServer.h */; };	1477	93D6B772254BB5190058DD3A /* SpeechRecognitionServer.h in Headers / = {isa = PBXBuildFile; fileRef = 93D6B76C254B89580058DD3A / SpeechRecognitionServer.h */; };
1473	93D6B773254BB8C70058DD3A /* WebSpeechRecognitionConnection.h in Headers / = {isa = PBXBuildFile; fileRef = 93D6B768254B7BC60058DD3A / WebSpeechRecognitionConnection.h */; };	1478	93D6B773254BB8C70058DD3A /* WebSpeechRecognitionConnection.h in Headers / = {isa = PBXBuildFile; fileRef = 93D6B768254B7BC60058DD3A / WebSpeechRecognitionConnection.h */; };
Lines 5350-5355 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec2
5350	93B26149227D147200B97A76 /* StorageManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageManager.h; sourceTree = "<group>"; };	5355	93B26149227D147200B97A76 /* StorageManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageManager.h; sourceTree = "<group>"; };
5351	93B2614A227D147200B97A76 /* StorageManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageManager.cpp; sourceTree = "<group>"; };	5356	93B2614A227D147200B97A76 /* StorageManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageManager.cpp; sourceTree = "<group>"; };
5352	93B2614C227D147200B97A76 /* LocalStorageDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LocalStorageDatabase.cpp; sourceTree = "<group>"; };	5357	93B2614C227D147200B97A76 /* LocalStorageDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LocalStorageDatabase.cpp; sourceTree = "<group>"; };
		5358	93B631E327ABA5F700443A44 /* IDBStorageConnectionToClient.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = IDBStorageConnectionToClient.cpp; sourceTree = "<group>"; };
		5359	93B631E427ABA62700443A44 /* IDBStorageConnectionToClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBStorageConnectionToClient.h; sourceTree = "<group>"; };
		5360	93B631E627ABA65C00443A44 /* IDBStorageManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBStorageManager.h; sourceTree = "<group>"; };
		5361	93B631E727ABA65C00443A44 /* IDBStorageManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBStorageManager.cpp; sourceTree = "<group>"; };
		5362	93B631EA27ABA6B200443A44 /* IDBStorageRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBStorageRegistry.cpp; sourceTree = "<group>"; };
		5363	93B631EB27ABA6B300443A44 /* IDBStorageRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBStorageRegistry.h; sourceTree = "<group>"; };
		5364	93B631EE27ABACA800443A44 /* QuotaManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = QuotaManager.cpp; sourceTree = "<group>"; };
		5365	93B631EF27ABACA900443A44 /* QuotaManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QuotaManager.h; sourceTree = "<group>"; };
		5366	93B631F227ABAD7F00443A44 /* QuotaIncreaseRequestIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QuotaIncreaseRequestIdentifier.h; sourceTree = "<group>"; };
5353	93BA04DA2151ADF3007F455F /* WebSWServerConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWServerConnection.messages.in; sourceTree = "<group>"; };	5367	93BA04DA2151ADF3007F455F /* WebSWServerConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWServerConnection.messages.in; sourceTree = "<group>"; };
5354	93BA04DB2151ADF3007F455F /* WebSWServerToContextConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSWServerToContextConnection.h; sourceTree = "<group>"; };	5368	93BA04DB2151ADF3007F455F /* WebSWServerToContextConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSWServerToContextConnection.h; sourceTree = "<group>"; };
5355	93BA04DC2151ADF3007F455F /* WebSWServerToContextConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWServerToContextConnection.messages.in; sourceTree = "<group>"; };	5369	93BA04DC2151ADF3007F455F /* WebSWServerToContextConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWServerToContextConnection.messages.in; sourceTree = "<group>"; };
Lines 7555-7560 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec3
7555	1ABF43781A368035003FB0E6 /* WebsiteData */ = {	7569	1ABF43781A368035003FB0E6 /* WebsiteData */ = {
7556	isa = PBXGroup;	7570	isa = PBXGroup;
7557	children = (	7571	children = (
		7572	93B631F227ABAD7F00443A44 /* QuotaIncreaseRequestIdentifier.h */,
7558	1A4832D41A9CDF96008B4DFE /* WebsiteData.cpp */,	7573	1A4832D41A9CDF96008B4DFE /* WebsiteData.cpp */,
7559	1A4832D51A9CDF96008B4DFE /* WebsiteData.h */,	7574	1A4832D51A9CDF96008B4DFE /* WebsiteData.h */,
7560	1A28B8CB1C80ED59006FD743 /* WebsiteDataFetchOption.h */,	7575	1A28B8CB1C80ED59006FD743 /* WebsiteDataFetchOption.h */,
Lines 10401-10406 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec4
10401	935B579826F51270008B48AC /* FileSystemStorageHandleRegistry.h */,	10416	935B579826F51270008B48AC /* FileSystemStorageHandleRegistry.h */,
10402	931A075126F06310004474CD /* FileSystemStorageManager.cpp */,	10417	931A075126F06310004474CD /* FileSystemStorageManager.cpp */,
10403	931A075026F06310004474CD /* FileSystemStorageManager.h */,	10418	931A075026F06310004474CD /* FileSystemStorageManager.h */,
		10419	93B631E327ABA5F700443A44 /* IDBStorageConnectionToClient.cpp */,
		10420	93B631E427ABA62700443A44 /* IDBStorageConnectionToClient.h */,
		10421	93B631E727ABA65C00443A44 /* IDBStorageManager.cpp */,
		10422	93B631E627ABA65C00443A44 /* IDBStorageManager.h */,
		10423	93B631EA27ABA6B200443A44 /* IDBStorageRegistry.cpp */,
		10424	93B631EB27ABA6B300443A44 /* IDBStorageRegistry.h */,
10404	93E799C92760497A0074008A /* LocalStorageManager.cpp */,	10425	93E799C92760497A0074008A /* LocalStorageManager.cpp */,
10405	93E799CB2760497A0074008A /* LocalStorageManager.h */,	10426	93E799CB2760497A0074008A /* LocalStorageManager.h */,
10406	93E799D8276121080074008A /* MemoryStorageArea.cpp */,	10427	93E799D8276121080074008A /* MemoryStorageArea.cpp */,
Lines 10410-10415 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec5
10410	93085DC726E1C6EE000EC6A7 /* NetworkStorageManager.messages.in */,	10431	93085DC726E1C6EE000EC6A7 /* NetworkStorageManager.messages.in */,
10411	93085DC526E1C6CF000EC6A7 /* OriginStorageManager.cpp */,	10432	93085DC526E1C6CF000EC6A7 /* OriginStorageManager.cpp */,
10412	93085DC626E1C6CF000EC6A7 /* OriginStorageManager.h */,	10433	93085DC626E1C6CF000EC6A7 /* OriginStorageManager.h */,
		10434	93B631EE27ABACA800443A44 /* QuotaManager.cpp */,
		10435	93B631EF27ABACA900443A44 /* QuotaManager.h */,
10413	93E799CC2760497B0074008A /* SessionStorageManager.cpp */,	10436	93E799CC2760497B0074008A /* SessionStorageManager.cpp */,
10414	93E799CA2760497A0074008A /* SessionStorageManager.h */,	10437	93E799CA2760497A0074008A /* SessionStorageManager.h */,
10415	93E799D3276121070074008A /* SQLiteStorageArea.cpp */,	10438	93E799D3276121070074008A /* SQLiteStorageArea.cpp */,
Lines 13018-13023 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec6
13018	312CC9F2215B06F100DE40CA /* HighPerformanceGPUManager.h in Headers */,	13041	312CC9F2215B06F100DE40CA /* HighPerformanceGPUManager.h in Headers */,
13019	839A2F321E2067450039057E /* HighPerformanceGraphicsUsageSampler.h in Headers */,	13042	839A2F321E2067450039057E /* HighPerformanceGraphicsUsageSampler.h in Headers */,
13020	51C0C9741DDD76000032CAD3 /* IconLoadingDelegate.h in Headers */,	13043	51C0C9741DDD76000032CAD3 /* IconLoadingDelegate.h in Headers */,
		13044	93B631E527ABA62800443A44 /* IDBStorageConnectionToClient.h in Headers */,
		13045	93B631E827ABA65D00443A44 /* IDBStorageManager.h in Headers */,
		13046	93B631ED27ABA6B400443A44 /* IDBStorageRegistry.h in Headers */,
13021	51E351CB180F2CCC00E53BE9 /* IDBUtilities.h in Headers */,	13047	51E351CB180F2CCC00E53BE9 /* IDBUtilities.h in Headers */,
13022	BCCF6B2512C93E7A008F9C35 /* ImageOptions.h in Headers */,	13048	BCCF6B2512C93E7A008F9C35 /* ImageOptions.h in Headers */,
13023	1A1EC69E1872092100B951F0 /* ImportanceAssertion.h in Headers */,	13049	1A1EC69E1872092100B951F0 /* ImportanceAssertion.h in Headers */,
Lines 13229-13234 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec7
13229	A1E688701F6E2BAB007006A6 /* QuarantineSPI.h in Headers */,	13255	A1E688701F6E2BAB007006A6 /* QuarantineSPI.h in Headers */,
13230	1A0C227E2451130A00ED614D /* QuickLookThumbnailingSoftLink.h in Headers */,	13256	1A0C227E2451130A00ED614D /* QuickLookThumbnailingSoftLink.h in Headers */,
13231	1AEE57252409F142002005D6 /* QuickLookThumbnailLoader.h in Headers */,	13257	1AEE57252409F142002005D6 /* QuickLookThumbnailLoader.h in Headers */,
		13258	93B631F327ABAD8000443A44 /* QuotaIncreaseRequestIdentifier.h in Headers */,
		13259	93B631F127ABACA900443A44 /* QuotaManager.h in Headers */,
13232	5CB6AE442609799C00B6ED5A /* ReasonSPI.h in Headers */,	13260	5CB6AE442609799C00B6ED5A /* ReasonSPI.h in Headers */,
13233	57FD318222B3515E008D0E8B /* RedirectSOAuthorizationSession.h in Headers */,	13261	57FD318222B3515E008D0E8B /* RedirectSOAuthorizationSession.h in Headers */,
13234	9B1229D223FF2BCC008CA751 /* RemoteAudioDestinationIdentifier.h in Headers */,	13262	9B1229D223FF2BCC008CA751 /* RemoteAudioDestinationIdentifier.h in Headers */,



#include "DataReference.h"
#include "NetworkConnectionToWebProcessMessages.h"
#include "NetworkProcessConnection.h"
#include "NetworkStorageManagerMessages.h"
#include "WebCoreArgumentCoders.h"
#include "WebIDBResult.h"
#include "WebIDBServerMessages.h"
#include "WebProcess.h"
#include <WebCore/IDBConnectionToServer.h>
#include <WebCore/IDBCursorInfo.h>


void WebIDBConnectionToServer::deleteDatabase(const IDBRequestData& requestData)
{
    send(Messages::NetworkStorageManager::DeleteDatabase(requestData));
}

void WebIDBConnectionToServer::openDatabase(const IDBRequestData& requestData)
{
    send(Messages::NetworkStorageManager::OpenDatabase(requestData));
}

void WebIDBConnectionToServer::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
{
    send(Messages::NetworkStorageManager::AbortTransaction(transactionIdentifier));
}

void WebIDBConnectionToServer::commitTransaction(const IDBResourceIdentifier& transactionIdentifier, uint64_t pendingRequestCount)
{
    send(Messages::NetworkStorageManager::CommitTransaction(transactionIdentifier, pendingRequestCount));
}

void WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
{
    send(Messages::NetworkStorageManager::DidFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier));
}

void WebIDBConnectionToServer::createObjectStore(const IDBRequestData& requestData, const IDBObjectStoreInfo& info)
{
    send(Messages::NetworkStorageManager::CreateObjectStore(requestData, info));
}

void WebIDBConnectionToServer::deleteObjectStore(const IDBRequestData& requestData, const String& objectStoreName)
{
    send(Messages::NetworkStorageManager::DeleteObjectStore(requestData, objectStoreName));
}

void WebIDBConnectionToServer::renameObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& newName)
{
    send(Messages::NetworkStorageManager::RenameObjectStore(requestData, objectStoreIdentifier, newName));
}

void WebIDBConnectionToServer::clearObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier)
{
    send(Messages::NetworkStorageManager::ClearObjectStore(requestData, objectStoreIdentifier));
}

void WebIDBConnectionToServer::createIndex(const IDBRequestData& requestData, const IDBIndexInfo& info)
{
    send(Messages::NetworkStorageManager::CreateIndex(requestData, info));
}

void WebIDBConnectionToServer::deleteIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
{
    send(Messages::NetworkStorageManager::DeleteIndex(requestData, objectStoreIdentifier, indexName));
}

void WebIDBConnectionToServer::renameIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
{
    send(Messages::NetworkStorageManager::RenameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName));
}

void WebIDBConnectionToServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode mode)
{
    send(Messages::NetworkStorageManager::PutOrAdd(requestData, keyData, value, mode));
}

void WebIDBConnectionToServer::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData)
{
    send(Messages::NetworkStorageManager::GetRecord(requestData, getRecordData));
}

void WebIDBConnectionToServer::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData)
{
    send(Messages::NetworkStorageManager::GetAllRecords(requestData, getAllRecordsData));
}

void WebIDBConnectionToServer::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& range)
{
    send(Messages::NetworkStorageManager::GetCount(requestData, range));
}

void WebIDBConnectionToServer::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& range)
{
    send(Messages::NetworkStorageManager::DeleteRecord(requestData, range));
}

void WebIDBConnectionToServer::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info)
{
    send(Messages::NetworkStorageManager::OpenCursor(requestData, info));
}

void WebIDBConnectionToServer::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data)
{
    send(Messages::NetworkStorageManager::IterateCursor(requestData, data));
}

void WebIDBConnectionToServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
{
    send(Messages::NetworkStorageManager::EstablishTransaction(databaseConnectionIdentifier, info));
}

void WebIDBConnectionToServer::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
{
    send(Messages::NetworkStorageManager::DatabaseConnectionPendingClose(databaseConnectionIdentifier));
}

void WebIDBConnectionToServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
{
    send(Messages::NetworkStorageManager::DatabaseConnectionClosed(databaseConnectionIdentifier));
}

void WebIDBConnectionToServer::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
{
    send(Messages::NetworkStorageManager::AbortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier));
}

void WebIDBConnectionToServer::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, const IndexedDB::ConnectionClosedOnBehalfOfServer connectionClosed)
{
    send(Messages::NetworkStorageManager::DidFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, connectionClosed));
}

void WebIDBConnectionToServer::openDBRequestCancelled(const IDBRequestData& requestData)
{
    send(Messages::NetworkStorageManager::OpenDBRequestCancelled(requestData));
}

void WebIDBConnectionToServer::getAllDatabaseNamesAndVersions(const IDBResourceIdentifier& requestIdentifier, const ClientOrigin& origin)
{
    send(Messages::NetworkStorageManager::GetAllDatabaseNamesAndVersions(requestIdentifier, origin));
}

void WebIDBConnectionToServer::didDeleteDatabase(const IDBResultData& result)

Lines 42-47 a/Source/WebKitLegacy/Storage/InProcessIDBServer.cpp_sec1
- a/Source/WebKitLegacy/Storage/InProcessIDBServer.cpp -1 / +3 lines
42		42
43	using namespace WebCore;	43	using namespace WebCore;
44		44
		45	static constexpr uint64_t defaultPerOriginQuota = 1000 * MB;
		46
45	Ref<InProcessIDBServer> InProcessIDBServer::create(PAL::SessionID sessionID)	47	Ref<InProcessIDBServer> InProcessIDBServer::create(PAL::SessionID sessionID)
46	{	48	{
47	ASSERT(sessionID.isEphemeral());	49	ASSERT(sessionID.isEphemeral());
Lines 73-79 InProcessIDBServer::~InProcessIDBServer() a/Source/WebKitLegacy/Storage/InProcessIDBServer.cpp_sec2
73	StorageQuotaManager* InProcessIDBServer::quotaManager(const ClientOrigin& origin)	75	StorageQuotaManager* InProcessIDBServer::quotaManager(const ClientOrigin& origin)
74	{	76	{
75	return m_quotaManagers.ensure(origin, [] {	77	return m_quotaManagers.ensure(origin, [] {
76	return StorageQuotaManager::create(StorageQuotaManager::defaultQuota(), [] {	78	return StorageQuotaManager::create(defaultPerOriginQuota, [] {
77	return 0;	79	return 0;
78	}, [](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {	80	}, [](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {
79	callback(quota + currentSpace + spaceIncrease);	81	callback(quota + currentSpace + spaceIncrease);



2022-02-03  Sihui Liu  <sihui_liu@apple.com>

        Manage IndexedDB storage by origin
        https://bugs.webkit.org/show_bug.cgi?id=234925
        <rdar://problem/87555014>

        Reviewed by NOBODY (OOPS!).

        Update existing tests for behavior change.

        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBFileName.mm:
        (runTest):
        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm:
        * TestWebKitAPI/Tests/WebKitCocoa/StoreBlobThenDelete.mm:
        (TEST):

2022-02-03  Jonathan Bedard  <jbedard@apple.com>

        [git-webkit] Configure default branch management 



    RetainPtr<NSString> string2 = (NSString *)[lastScriptMessage body];
    EXPECT_WK_STREQ(@"Success", string2.get());

    // All databases of an origin are migrated to new version directory when the origin is accessed.
    auto defaultFileManager = [NSFileManager defaultManager];
    NSString *existingDatabaseName = @"IndexedDBTest";
    NSString *createdDatabaseName = @"IndexedDBOther";
    NSString *unusedDatabaseName = @"IndexedDBUnused";
    NSString *existingDatbaseHash = WebCore::SQLiteFileSystem::computeHashForFileName(existingDatabaseName);
    NSString *createdDatabaseHash = WebCore::SQLiteFileSystem::computeHashForFileName(createdDatabaseName);
    NSString *unusedDatabaseHash = WebCore::SQLiteFileSystem::computeHashForFileName(createdDatabaseName);
    NSURL *idbRootURL = [[WKWebsiteDataStore defaultDataStore] _indexedDBDatabaseDirectory];
    NSURL *oldVersionDirectoryURL = [idbRootURL URLByAppendingPathComponent:@"v0"];
    NSURL *newVersionDirectoryURL = [idbRootURL URLByAppendingPathComponent:@"v1"];
    NSURL *oldVersionOriginDirectoryURL = [oldVersionDirectoryURL URLByAppendingPathComponent: @"file__0"];
    NSURL *newVersionOriginDirectoryURL = [newVersionDirectoryURL URLByAppendingPathComponent: @"file__0"];
    NSURL *oldVersionUnusedDatabaseDirectoryURL = [oldVersionOriginDirectoryURL URLByAppendingPathComponent:unusedDatabaseName];
    NSURL *newVersionUnusedDatabaseDirectoryURL = [newVersionOriginDirectoryURL URLByAppendingPathComponent:unusedDatabaseHash];
    EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:oldVersionUnusedDatabaseDirectoryURL.path]);
    EXPECT_TRUE([[NSFileManager defaultManager] fileExistsAtPath:newVersionUnusedDatabaseDirectoryURL.path]);
    
    // For database that is opened after upgrade, its file should only be in v1.
    NSURL *oldVersionExistingDatabaseDirectoryURL = [oldVersionOriginDirectoryURL URLByAppendingPathComponent: existingDatabaseName];

Lines 305-314 TEST(IndexedDB, IndexedDBThirdPartyDataRemoval) a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm -4 / +8 lines
305	EXPECT_WK_STREQ( @"database is created - put item success", (NSString *)[lastScriptMessage body]);	305	EXPECT_WK_STREQ( @"database is created - put item success", (NSString *)[lastScriptMessage body]);
306		306
307	readyToContinue = false;	307	readyToContinue = false;
308	[[WKWebsiteDataStore defaultDataStore] fetchDataRecordsOfTypes:websiteDataTypes.get() completionHandler:^(NSArray<WKWebsiteDataRecord > dataRecords) {	308	[[WKWebsiteDataStore defaultDataStore] fetchDataRecordsOfTypes:websiteDataTypes.get() completionHandler:^(NSArray<WKWebsiteDataRecord > records) {
309	EXPECT_EQ(1u, dataRecords.count);	309	EXPECT_EQ(2u, records.count);
310	EXPECT_WK_STREQ("iframe", [[dataRecords firstObject] displayName]);	310	NSSortDescriptor *recordDescriptor = [NSSortDescriptor sortDescriptorWithKey:@"displayName" ascending:YES];
311	[[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:websiteDataTypes.get() forDataRecords:dataRecords completionHandler:^() {	311	NSArray *sortDescriptors = @[recordDescriptor];
		312	NSArray *sortedRecords = [records sortedArrayUsingDescriptors:sortDescriptors];
		313	EXPECT_WK_STREQ("iframe", [[sortedRecords objectAtIndex:0] displayName]);
		314	EXPECT_WK_STREQ("webkit.org", [[sortedRecords objectAtIndex:1] displayName]);
		315	[[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:websiteDataTypes.get() forDataRecords:records completionHandler:^() {
312	readyToContinue = true;	316	readyToContinue = true;
313	}];	317	}];
314	}];	318	}];



    [[NSFileManager defaultManager] copyItemAtPath:databaseFilePath toPath:fakeShmPath error:nil];
    [[NSFileManager defaultManager] copyItemAtPath:databaseFilePath toPath:fakeWalPath error:nil];

    // Make some other .blob files in the database directory to later validate all blob files in the directory are deleted.
    NSString *otherBlob1 = [databaseDirectory stringByAppendingPathComponent:@"7182.blob"];
    NSString *otherBlob2 = [databaseDirectory stringByAppendingPathComponent:@"1a.blob"];
    NSString *otherBlob3 = [databaseDirectory stringByAppendingPathComponent:@"a1.blob"];

        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:blobFilePath]);
        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:databaseFilePath]);

        // Make sure all fake blob file are gone.
        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob1]);

        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob2]);
        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob3]);
        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob4]);
        EXPECT_TRUE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob4]);

        // Make sure everything related to the fake database is gone.
        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:fakeShmPath]);

Lines 40-47 a/Tools/WebKitTestRunner/WebKitTestRunner.xcodeproj/xcshareddata/xcschemes/WebKitTestRunner.xcscheme_sec1
- a/Tools/WebKitTestRunner/WebKitTestRunner.xcodeproj/xcshareddata/xcschemes/WebKitTestRunner.xcscheme -3 / +12 lines
40	debugDocumentVersioning = "YES"	40	debugDocumentVersioning = "YES"
41	debugServiceExtension = "internal"	41	debugServiceExtension = "internal"
42	allowLocationSimulation = "YES">	42	allowLocationSimulation = "YES">
43	<BuildableProductRunnable	43	<PathRunnable
44	runnableDebuggingMode = "0">	44	runnableDebuggingMode = "0"
		45	FilePath = "/Users/sihuil/Data/WebKit1/OpenSource/WebKitBuild/Debug/WebKitTestRunner">
		46	</PathRunnable>
		47	<MacroExpansion>
45	<BuildableReference	48	<BuildableReference
46	BuildableIdentifier = "primary"	49	BuildableIdentifier = "primary"
47	BlueprintIdentifier = "8DD76F960486AA7600D96B5E"	50	BlueprintIdentifier = "8DD76F960486AA7600D96B5E"
Lines 49-55 a/Tools/WebKitTestRunner/WebKitTestRunner.xcodeproj/xcshareddata/xcschemes/WebKitTestRunner.xcscheme_sec2
49	BlueprintName = "WebKitTestRunner"	52	BlueprintName = "WebKitTestRunner"
50	ReferencedContainer = "container:WebKitTestRunner.xcodeproj">	53	ReferencedContainer = "container:WebKitTestRunner.xcodeproj">
51	</BuildableReference>	54	</BuildableReference>
52	</BuildableProductRunnable>	55	</MacroExpansion>
		56	<CommandLineArguments>
		57	<CommandLineArgument
		58	argument = "/Users/sihuil/Data/WebKit1/OpenSource/LayoutTests/imported/w3c/IndexedDB-private-browsing/abort-in-initial-upgradeneeded.html"
		59	isEnabled = "YES">
		60	</CommandLineArgument>
		61	</CommandLineArguments>
53	</LaunchAction>	62	</LaunchAction>
54	<ProfileAction	63	<ProfileAction
55	buildConfiguration = "Release"	64	buildConfiguration = "Release"

Return to Bug 234925

Lines 1-3 a/Source/WTF/ChangeLog_sec1
- a/Source/WTF/ChangeLog +14 lines
		1	2022-02-03 Sihui Liu <sihui_liu@apple.com>
		2
		3	Manage IndexedDB storage by origin
		4	https://bugs.webkit.org/show_bug.cgi?id=234925
		5	<rdar://problem/87555014>
		6
		7	Reviewed by NOBODY (OOPS!).
		8
		9	Add a helper function to get the target from a symoblic link path.
		10
		11	* wtf/FileSystem.cpp:
		12	(WTF::FileSystemImpl::getSymbolicLinkTarget):
		13	* wtf/FileSystem.h:
		14
1	2022-02-03 Robert Jenner <Jenner@apple.com>	15	2022-02-03 Robert Jenner <Jenner@apple.com>
2		16
3	Unreviewed, reverting r288902.	17	Unreviewed, reverting r288902.

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +93 lines
		1	2022-02-03 Sihui Liu <sihui_liu@apple.com>
		2
		3	Manage IndexedDB storage by origin
		4	https://bugs.webkit.org/show_bug.cgi?id=234925
		5	<rdar://problem/87555014>
		6
		7	Reviewed by NOBODY (OOPS!).
		8
		9	Both WebKit and WebKitLegacy used IDBServer to manage UniqueIDBDatabases, and UniqueIDBDatabase pointed to
		10	IDBServer. Now that WebKit uses WebKit::IDBStorageManager to manage UniqueIDBDatabases. We untie the
		11	knot between IDBServer and UniqueIDBDatabase by adding a new abstract class UniqueIDBDatabaseManager and make
		12	UniqueIDBDatabase point to UniqueIDBDatabaseManager.
		13
		14	Also, as quota check is no longer async according to changes in WebKit, we need to update operations in
		15	UniqueIDBDatabase to adopt the change.
		16
		17	Covered by existing tests.
		18
		19	* Headers.cmake:
		20	* Modules/indexeddb/IDBDatabaseIdentifier.h:
		21	* Modules/indexeddb/server/IDBConnectionToClient.h:
		22	* Modules/indexeddb/server/IDBServer.cpp:
		23	(WebCore::IDBServer::IDBServer::registerConnection):
		24	(WebCore::IDBServer::IDBServer::unregisterConnection):
		25	(WebCore::IDBServer::IDBServer::createBackingStore):
		26	(WebCore::IDBServer::IDBServer::upgradedDatabaseDirectory):
		27	(WebCore::IDBServer::IDBServer::registerDatabaseConnection): Deleted.
		28	(WebCore::IDBServer::IDBServer::unregisterDatabaseConnection): Deleted.
		29	(WebCore::IDBServer::IDBServer::closeAndTakeUniqueIDBDatabase): Deleted.
		30	* Modules/indexeddb/server/IDBServer.h:
		31	* Modules/indexeddb/server/MemoryIDBBackingStore.cpp:
		32	(WebCore::IDBServer::MemoryIDBBackingStore::MemoryIDBBackingStore):
		33	(WebCore::IDBServer::MemoryIDBBackingStore::createObjectStore):
		34	* Modules/indexeddb/server/MemoryIDBBackingStore.h:
		35	* Modules/indexeddb/server/MemoryObjectStore.cpp:
		36	(WebCore::IDBServer::MemoryObjectStore::create):
		37	(WebCore::IDBServer::MemoryObjectStore::MemoryObjectStore):
		38	* Modules/indexeddb/server/MemoryObjectStore.h:
		39	* Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
		40	(WebCore::IDBServer::SQLiteIDBBackingStore::SQLiteIDBBackingStore):
		41	(WebCore::IDBServer::SQLiteIDBBackingStore::encodeDatabaseName):
		42	(WebCore::IDBServer::SQLiteIDBBackingStore::decodeDatabaseName):
		43	(WebCore::IDBServer::SQLiteIDBBackingStore::getOrEstablishDatabaseInfo):
		44	(WebCore::IDBServer::SQLiteIDBBackingStore::deleteBackingStore):
		45	(WebCore::IDBServer::SQLiteIDBBackingStore::filenameForDatabaseName const): Deleted.
		46	(WebCore::IDBServer::SQLiteIDBBackingStore::fullDatabaseDirectoryWithUpgrade): Deleted.
		47	* Modules/indexeddb/server/SQLiteIDBBackingStore.h:
		48	* Modules/indexeddb/server/UniqueIDBDatabase.cpp:
		49	(WebCore::IDBServer::UniqueIDBDatabase::UniqueIDBDatabase):
		50	(WebCore::IDBServer::UniqueIDBDatabase::manager):
		51	(WebCore::IDBServer::UniqueIDBDatabase::performCurrentOpenOperation):
		52	(WebCore::IDBServer::UniqueIDBDatabase::performCurrentOpenOperationAfterSpaceCheck):
		53	(WebCore::IDBServer::UniqueIDBDatabase::deleteBackingStore):
		54	(WebCore::IDBServer::UniqueIDBDatabase::createObjectStore):
		55	(WebCore::IDBServer::UniqueIDBDatabase::deleteObjectStore):
		56	(WebCore::IDBServer::UniqueIDBDatabase::renameObjectStore):
		57	(WebCore::IDBServer::UniqueIDBDatabase::clearObjectStore):
		58	(WebCore::IDBServer::UniqueIDBDatabase::createIndex):
		59	(WebCore::IDBServer::UniqueIDBDatabase::deleteIndex):
		60	(WebCore::IDBServer::UniqueIDBDatabase::renameIndex):
		61	(WebCore::IDBServer::UniqueIDBDatabase::putOrAdd):
		62	(WebCore::IDBServer::UniqueIDBDatabase::putOrAddAfterSpaceCheck):
		63	(WebCore::IDBServer::UniqueIDBDatabase::getRecord):
		64	(WebCore::IDBServer::UniqueIDBDatabase::getAllRecords):
65	(WebCore::IDBServer::UniqueIDBDatabase::getCount):
66	(WebCore::IDBServer::UniqueIDBDatabase::deleteRecord):
67	(WebCore::IDBServer::UniqueIDBDatabase::openCursor):
68	(WebCore::IDBServer::UniqueIDBDatabase::iterateCursor):
69	(WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):
70	(WebCore::IDBServer::UniqueIDBDatabase::abortTransaction):
71	(WebCore::IDBServer::UniqueIDBDatabase::abortInProgressTransactions):
72	(WebCore::IDBServer::UniqueIDBDatabase::hasDataInMemory const):
73	* Modules/indexeddb/server/UniqueIDBDatabase.h:
74	(WebCore::IDBServer::UniqueIDBDatabase::server): Deleted.
75	* Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp:
76	(WebCore::IDBServer::UniqueIDBDatabaseConnection::UniqueIDBDatabaseConnection):
77	(WebCore::IDBServer::UniqueIDBDatabaseConnection::~UniqueIDBDatabaseConnection):
78	(WebCore::IDBServer::UniqueIDBDatabaseConnection::manager):
79	* Modules/indexeddb/server/UniqueIDBDatabaseConnection.h:
80	(WebCore::IDBServer::UniqueIDBDatabaseConnection::server): Deleted.
81	* Modules/indexeddb/server/UniqueIDBDatabaseManager.h: Added.
82	(WebCore::IDBServer::UniqueIDBDatabaseManager::~UniqueIDBDatabaseManager):
83	* Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp:
84	(WebCore::IDBServer::UniqueIDBDatabaseTransaction::UniqueIDBDatabaseTransaction):
85	(WebCore::IDBServer::UniqueIDBDatabaseTransaction::~UniqueIDBDatabaseTransaction):
86	* Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h:
87	* Modules/indexeddb/shared/IDBError.h:
88	(WebCore::IDBError::operator bool const):
89	* Modules/indexeddb/shared/IDBRequestData.h:
90	* Modules/indexeddb/shared/IDBResourceIdentifier.h:
91	(WebCore::IDBResourceIdentifier::operator!= const):
92	* WebCore.xcodeproj/project.pbxproj:
93
1	2022-02-03 Ben Nham <nham@apple.com>	94	2022-02-03 Ben Nham <nham@apple.com>
2		95
3	LocalStorage values should be 8-bit strings in memory if possible	96	LocalStorage values should be 8-bit strings in memory if possible

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +262 lines
		1	2022-02-03 Sihui Liu <sihui_liu@apple.com>
		2
		3	Manage IndexedDB storage by origin
		4	https://bugs.webkit.org/show_bug.cgi?id=234925
		5	<rdar://problem/87555014>
		6
		7	Reviewed by NOBODY (OOPS!).
		8
		9	In network process, IndexedDB data is managed by WebKit::WebIDBServer. Each session owns a WebIDBServer
		10	(IDBServer) and each IDBServer owns one or more UniqueIDBDatabases (resprenting one actual database that
		11	IDBDatabase connects to, can be identified by {session, origin, name}). Now that we have NetworkStorageManager,
		12	which manages session storage by origin, we can merge WebIDBServer with NetworkStorageManager, since IndexedDB
		13	storage is not shared across origins.
		14
		15	The old structure is:
		16	NetworkSession - WebIDBServer - IDBServer - UniqueIDBDatabases
		17	The new structure is:
		18	NetworkSession - NetworkStorageManager - OriginStorageManager - IDBStorageManager - UniqueIDBDatabase
		19
		20	To complete this transition, we need to make a few changes:
		21	1. Web process now sends IndexedDB related messages to NetworkStorageManager instead of WebIDBServer.
		22	2. Some messages are sent to operate on UniqueIDBDatabaseConnection or UniqueIDBDatabaseTransaction, and they
		23	use identifiers to specify the target. Therefore, NetworkStorageManagers needs to know the mapping between
		24	identifiers and target objects. We add a new IDBStorageRegistry class to record this mapping. Each
		25	NetworkStorageManager owns a IDBStorageRegistry and it passes IDBStorageRegistry to IDBStorageManager,
		26	IDBStorageManager will register objects to IDBStorageRegistry and NetworkStorageManager can do search via
		27	IDBStorageRegistry.
		28	3. Quota check for IndexedDB operations becomes async by adding new QuotaManager class, which is similar to
		29	WebCore::StorageQuotaManager but provides async interfaces.
		30	We used to block the IDBServer thread when it is waiting for quota check result from UI process, this is fine
		31	because IDBServer runs on its own thread. Now that IDBStorageManager runs on the same thread as the other
		32	storage types, we cannot block the thread on quota check.
		33	4. Rename WebIDBConnectionToClient to IDBStorageConnectionToClient to reflect the change on the structure. Also,
		34	IDBStorageConnectionToClient does not keep reference to the IPC::Connection now, it only records
		35	IPC::Connection::UniqueID.
		36	5. IndexedDB data may be put in different version dirctories. We used to migrate database to new version
		37	diretory when the database is accessed. As IDBStorageManager now manages IndexedDB data of one origin, it's
		38	simpler if it only keeps track of one directory. Therefore, we now migrate all databases of one origin
		39	when the origin is accessed (see IDBStorageManager::idbStorageOriginDirectory).
		40
		41	* NetworkProcess/NetworkConnectionToWebProcess.cpp:
		42	(WebKit::NetworkConnectionToWebProcess::updateQuotaBasedOnSpaceUsageForTesting):
		43	(WebKit::NetworkConnectionToWebProcess::writeBlobsToTemporaryFilesForIndexedDB):
		44	* NetworkProcess/NetworkProcess.cpp:
		45	(WebKit::NetworkProcess::didClose):
		46	(WebKit::NetworkProcess::createNetworkConnectionToWebProcess):
		47	(WebKit::NetworkProcess::addWebsiteDataStore):
		48	(WebKit::NetworkProcess::fetchWebsiteData):
		49	(WebKit::NetworkProcess::deleteWebsiteData):
		50	(WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
		51	(WebKit::NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains):
		52	(WebKit::NetworkProcess::registrableDomainsWithWebsiteData):
		53	(WebKit::NetworkProcess::prepareToSuspend):
		54	(WebKit::NetworkProcess::resume):
		55	(WebKit::NetworkProcess::resetQuota):
		56	(WebKit::NetworkProcess::didIncreaseQuota):
		57	(WebKit::NetworkProcess::renameOriginInWebsiteData):
		58	(WebKit::NetworkProcess::storageQuotaManager):
		59	(WebKit::NetworkProcess::connectionToWebProcessClosed):
		60	(WebKit::NetworkProcess::suspendIDBServers): Deleted.
		61	* NetworkProcess/NetworkProcess.h:
		62	(WebKit::NetworkProcess::shouldSuspendIDBServers const): Deleted.
		63	* NetworkProcess/NetworkProcess.messages.in:
		64	* NetworkProcess/NetworkSession.cpp:
65	(WebKit::NetworkSession::invalidateAndCancel):
66	(WebKit::NetworkSession::addStorageManagerSession):
67	(WebKit::NetworkSession::ensureWebIDBServer): Deleted.
68	(WebKit::NetworkSession::closeIDBServer): Deleted.
69	(WebKit::NetworkSession::addIndexedDatabaseSession): Deleted.
70	* NetworkProcess/NetworkSession.h:
71	(WebKit::NetworkSession::webIDBServer): Deleted.
72	(WebKit::NetworkSession::hasIDBDatabasePath const): Deleted.
73	* NetworkProcess/cache/CacheStorageEngine.cpp:
74	(WebKit::CacheStorage::Engine::storagePath):
75	(WebKit::CacheStorage::Engine::diskUsage):
76	(WebKit::CacheStorage::Engine::requestSpace):
77	* NetworkProcess/cache/CacheStorageEngine.h:
78	* NetworkProcess/cache/CacheStorageEngineCaches.cpp:
79	(WebKit::CacheStorage::Caches::requestSpace):
80	* NetworkProcess/ios/NetworkProcessIOS.mm:
81	(WebKit::NetworkProcess::setIsHoldingLockedFiles):
82	* NetworkProcess/storage/IDBStorageConnectionToClient.cpp: Added.
83	(WebKit::IDBStorageConnectionToClient::IDBStorageConnectionToClient):
84	(WebKit::IDBStorageConnectionToClient::~IDBStorageConnectionToClient):
85	(WebKit::IDBStorageConnectionToClient::connectionToClient):
86	(WebKit::IDBStorageConnectionToClient::didGetResult):
87	(WebKit::IDBStorageConnectionToClient::didDeleteDatabase):
88	(WebKit::IDBStorageConnectionToClient::didOpenDatabase):
89	(WebKit::IDBStorageConnectionToClient::didStartTransaction):
90	(WebKit::IDBStorageConnectionToClient::didAbortTransaction):
91	(WebKit::IDBStorageConnectionToClient::didCommitTransaction):
92	(WebKit::IDBStorageConnectionToClient::didCreateObjectStore):
93	(WebKit::IDBStorageConnectionToClient::didDeleteObjectStore):
94	(WebKit::IDBStorageConnectionToClient::didRenameObjectStore):
95	(WebKit::IDBStorageConnectionToClient::didClearObjectStore):
96	(WebKit::IDBStorageConnectionToClient::didCreateIndex):
97	(WebKit::IDBStorageConnectionToClient::didDeleteIndex):
98	(WebKit::IDBStorageConnectionToClient::didRenameIndex):
99	(WebKit::IDBStorageConnectionToClient::didPutOrAdd):
100	(WebKit::IDBStorageConnectionToClient::didGetRecord):
101	(WebKit::IDBStorageConnectionToClient::didGetAllRecords):
102	(WebKit::IDBStorageConnectionToClient::didGetCount):
103	(WebKit::IDBStorageConnectionToClient::didDeleteRecord):
104	(WebKit::IDBStorageConnectionToClient::didOpenCursor):
105	(WebKit::IDBStorageConnectionToClient::didIterateCursor):
106	(WebKit::IDBStorageConnectionToClient::didGetAllDatabaseNamesAndVersions):
107	(WebKit::IDBStorageConnectionToClient::fireVersionChangeEvent):
108	(WebKit::IDBStorageConnectionToClient::didCloseFromServer):
109	(WebKit::IDBStorageConnectionToClient::notifyOpenDBRequestBlocked):
110	* NetworkProcess/storage/IDBStorageConnectionToClient.h: Added.
111	* NetworkProcess/storage/IDBStorageManager.cpp: Added.
112	(WebKit::migrateOriginData):
113	(WebKit::IDBStorageManager::idbStorageOriginDirectory):
114	(WebKit::IDBStorageManager::idbStorageSize):
115	(WebKit::getOriginsForVersion):
116	(WebKit::IDBStorageManager::originsOfIDBStorageData):
117	(WebKit::IDBStorageManager::IDBStorageManager):
118	(WebKit::IDBStorageManager::isActive const):
119	(WebKit::IDBStorageManager::hasDataInMemory const):
120	(WebKit::IDBStorageManager::closeDatabasesForDeletion):
121	(WebKit::IDBStorageManager::stopDatabaseActivitiesForSuspend):
122	(WebKit::IDBStorageManager::getOrCreateUniqueIDBDatabase):
123	(WebKit::IDBStorageManager::openDatabase):
124	(WebKit::IDBStorageManager::deleteDatabase):
125	(WebKit::IDBStorageManager::getAllDatabaseNamesAndVersions):
126	(WebKit::IDBStorageManager::openDBRequestCancelled):
127	(WebKit::IDBStorageManager::registerConnection):
128	(WebKit::IDBStorageManager::unregisterConnection):
129	(WebKit::IDBStorageManager::registerTransaction):
130	(WebKit::IDBStorageManager::unregisterTransaction):
131	(WebKit::IDBStorageManager::createBackingStore):
132	(WebKit::IDBStorageManager::requestSpace):
133	* NetworkProcess/storage/IDBStorageManager.h: Added.
134	* NetworkProcess/storage/IDBStorageRegistry.cpp: Added.
135	(WebKit::IDBStorageRegistry::getOrCreateConnectionToClient):
136	(WebKit::IDBStorageRegistry::removeConnectionToClient):
137	(WebKit::IDBStorageRegistry::registerConnection):
138	(WebKit::IDBStorageRegistry::unregisterConnection):
139	(WebKit::IDBStorageRegistry::registerTransaction):
140	(WebKit::IDBStorageRegistry::unregisterTransaction):
141	(WebKit::IDBStorageRegistry::getConnection):
142	(WebKit::IDBStorageRegistry::getTransaction):
143	* NetworkProcess/storage/IDBStorageRegistry.h: Added.
144	* NetworkProcess/storage/NetworkStorageManager.cpp:
145	(WebKit::NetworkStorageManager::create):
146	(WebKit::NetworkStorageManager::NetworkStorageManager):
147	(WebKit::NetworkStorageManager::canHandleTypes):
148	(WebKit::NetworkStorageManager::stopReceivingMessageFromConnection):
149	(WebKit::NetworkStorageManager::localOriginStorageManager):
150	(WebKit::NetworkStorageManager::didIncreaseQuota):
151	(WebKit::NetworkStorageManager::getAllOrigins):
152	(WebKit::NetworkStorageManager::moveData):
153	(WebKit::NetworkStorageManager::suspend):
154	(WebKit::NetworkStorageManager::registerTemporaryBlobFilePaths):
155	(WebKit::NetworkStorageManager::requestSpace):
156	(WebKit::NetworkStorageManager::resetQuotaForTesting):
157	(WebKit::NetworkStorageManager::resetQuotaUpdatedBasedOnUsageForTesting):
158	(WebKit::NetworkStorageManager::openDatabase):
159	(WebKit::NetworkStorageManager::openDBRequestCancelled):
160	(WebKit::NetworkStorageManager::deleteDatabase):
161	(WebKit::NetworkStorageManager::establishTransaction):
162	(WebKit::NetworkStorageManager::databaseConnectionPendingClose):
163	(WebKit::NetworkStorageManager::databaseConnectionClosed):
164	(WebKit::NetworkStorageManager::abortOpenAndUpgradeNeeded):
165	(WebKit::NetworkStorageManager::didFireVersionChangeEvent):
166	(WebKit::NetworkStorageManager::abortTransaction):
167	(WebKit::NetworkStorageManager::commitTransaction):
168	(WebKit::NetworkStorageManager::didFinishHandlingVersionChangeTransaction):
169	(WebKit::NetworkStorageManager::createObjectStore):
170	(WebKit::NetworkStorageManager::deleteObjectStore):
171	(WebKit::NetworkStorageManager::renameObjectStore):
172	(WebKit::NetworkStorageManager::clearObjectStore):
173	(WebKit::NetworkStorageManager::createIndex):
174	(WebKit::NetworkStorageManager::deleteIndex):
175	(WebKit::NetworkStorageManager::renameIndex):
176	(WebKit::NetworkStorageManager::putOrAdd):
177	(WebKit::NetworkStorageManager::getRecord):
178	(WebKit::NetworkStorageManager::getAllRecords):
179	(WebKit::NetworkStorageManager::getCount):
180	(WebKit::NetworkStorageManager::deleteRecord):
181	(WebKit::NetworkStorageManager::openCursor):
182	(WebKit::NetworkStorageManager::iterateCursor):
183	(WebKit::NetworkStorageManager::getAllDatabaseNamesAndVersions):
184	* NetworkProcess/storage/NetworkStorageManager.h:
185	* NetworkProcess/storage/NetworkStorageManager.messages.in:
186	* NetworkProcess/storage/OriginStorageManager.cpp:
187	(WebKit::OriginStorageManager::StorageBucket::StorageBucket):
188	(WebKit::OriginStorageManager::StorageBucket::toWebsiteDataType):
189	(WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier):
190	(WebKit::OriginStorageManager::StorageBucket::idbStorageManager):
191	(WebKit::OriginStorageManager::StorageBucket::existingIDBStorageManager):
192	(WebKit::OriginStorageManager::StorageBucket::isActive const):
193	(WebKit::OriginStorageManager::StorageBucket::isEmpty const):
194	(WebKit::OriginStorageManager::StorageBucket::deleteData):
195	(WebKit::OriginStorageManager::StorageBucket::moveData):
196	(WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromMemory):
197	(WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromDisk):
198	(WebKit::OriginStorageManager::StorageBucket::deleteIDBStorageData):
199	(WebKit::createQuotaManager):
200	(WebKit::OriginStorageManager::OriginStorageManager):
201	(WebKit::OriginStorageManager::defaultBucket):
202	(WebKit::OriginStorageManager::quotaManager):
203	(WebKit::OriginStorageManager::idbStorageManager):
204	(WebKit::OriginStorageManager::existingIDBStorageManager):
205	(WebKit::OriginStorageManager::moveData):
206	* NetworkProcess/storage/OriginStorageManager.h:
207	* NetworkProcess/storage/QuotaManager.cpp: Added.
208	(WebKit::QuotaManager::create):
209	(WebKit::QuotaManager::QuotaManager):
210	(WebKit::QuotaManager::requestSpace):
211	(WebKit::QuotaManager::handleRequests):
212	(WebKit::QuotaManager::grantWithCurrentQuota):
213	(WebKit::QuotaManager::grantFastPath):
214	(WebKit::QuotaManager::didIncreaseQuota):
215	(WebKit::QuotaManager::resetQuotaUpdatedBasedOnUsageForTesting):
216	(WebKit::QuotaManager::resetQuotaForTesting):
217	* NetworkProcess/storage/QuotaManager.h: Added.
218	* Scripts/webkit/messages.py:
219	(types_that_cannot_be_forward_declared):
220	* Shared/WebsiteData/QuotaIncreaseRequestIdentifier.h: Added.
221	* Shared/WebsiteDataStoreParameters.h:
222	* Sources.txt:
223	* UIProcess/Network/NetworkProcessProxy.cpp:
224	(WebKit::NetworkProcessProxy::increaseQuota):
225	* UIProcess/Network/NetworkProcessProxy.h:
226	* UIProcess/Network/NetworkProcessProxy.messages.in:
227	* UIProcess/WebsiteData/WebsiteDataStore.cpp:
228	(WebKit::WebsiteDataStore::perThirdPartyOriginStorageQuota const):
229	* UIProcess/WebsiteData/WebsiteDataStore.h:
230	(WebKit::WebsiteDataStore::defaultPerOriginQuota):
231	* UIProcess/WebsiteData/WebsiteDataStoreConfiguration.cpp:
232	(WebKit::WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration):
233	* UIProcess/WebsiteData/WebsiteDataStoreConfiguration.h:
234	* WebKit.xcodeproj/project.pbxproj:
235	* WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
236	(WebKit::WebIDBConnectionToServer::deleteDatabase):
237	(WebKit::WebIDBConnectionToServer::openDatabase):
238	(WebKit::WebIDBConnectionToServer::abortTransaction):
239	(WebKit::WebIDBConnectionToServer::commitTransaction):
240	(WebKit::WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
241	(WebKit::WebIDBConnectionToServer::createObjectStore):
242	(WebKit::WebIDBConnectionToServer::deleteObjectStore):
243	(WebKit::WebIDBConnectionToServer::renameObjectStore):
244	(WebKit::WebIDBConnectionToServer::clearObjectStore):
245	(WebKit::WebIDBConnectionToServer::createIndex):
246	(WebKit::WebIDBConnectionToServer::deleteIndex):
247	(WebKit::WebIDBConnectionToServer::renameIndex):
248	(WebKit::WebIDBConnectionToServer::putOrAdd):
249	(WebKit::WebIDBConnectionToServer::getRecord):
250	(WebKit::WebIDBConnectionToServer::getAllRecords):
251	(WebKit::WebIDBConnectionToServer::getCount):
252	(WebKit::WebIDBConnectionToServer::deleteRecord):
253	(WebKit::WebIDBConnectionToServer::openCursor):
254	(WebKit::WebIDBConnectionToServer::iterateCursor):
255	(WebKit::WebIDBConnectionToServer::establishTransaction):
256	(WebKit::WebIDBConnectionToServer::databaseConnectionPendingClose):
257	(WebKit::WebIDBConnectionToServer::databaseConnectionClosed):
258	(WebKit::WebIDBConnectionToServer::abortOpenAndUpgradeNeeded):
259	(WebKit::WebIDBConnectionToServer::didFireVersionChangeEvent):
260	(WebKit::WebIDBConnectionToServer::openDBRequestCancelled):
261	(WebKit::WebIDBConnectionToServer::getAllDatabaseNamesAndVersions):
262
1	2022-02-03 Sihui Liu <sihui_liu@apple.com>	263	2022-02-03 Sihui Liu <sihui_liu@apple.com>
2		264
3	Delay writing origin file in NetworkStorageManager	265	Delay writing origin file in NetworkStorageManager

Lines 1-3 a/Source/WebKitLegacy/ChangeLog_sec1
- a/Source/WebKitLegacy/ChangeLog +11 lines
		1	2022-02-03 Sihui Liu <sihui_liu@apple.com>
		2
		3	Manage IndexedDB storage by origin
		4	https://bugs.webkit.org/show_bug.cgi?id=234925
		5	<rdar://problem/87555014>
		6
		7	Reviewed by NOBODY (OOPS!).
		8
		9	* Storage/InProcessIDBServer.cpp:
		10	(InProcessIDBServer::quotaManager):
		11
1	2022-02-02 Elliott Williams <emw@apple.com>	12	2022-02-02 Elliott Williams <emw@apple.com>
2		13
3	[Xcode] Fix redundant execution of "Check VTables..." script	14	[Xcode] Fix redundant execution of "Check VTables..." script

Lines 224-234 set(WebCore_PRIVATE_FRAMEWORK_HEADERS a/Source/WebCore/Headers.cmake_sec1
- a/Source/WebCore/Headers.cmake +4 lines
224	Modules/indexeddb/server/IDBConnectionToClient.h	224	Modules/indexeddb/server/IDBConnectionToClient.h
225	Modules/indexeddb/server/IDBConnectionToClientDelegate.h	225	Modules/indexeddb/server/IDBConnectionToClientDelegate.h
226	Modules/indexeddb/server/IDBServer.h	226	Modules/indexeddb/server/IDBServer.h
		227	Modules/indexeddb/server/IndexValueEntry.h
		228	Modules/indexeddb/server/IndexValueStore.h
		229	Modules/indexeddb/server/MemoryBackingStoreTransaction.h
227	Modules/indexeddb/server/MemoryIDBBackingStore.h	230	Modules/indexeddb/server/MemoryIDBBackingStore.h
228	Modules/indexeddb/server/SQLiteIDBBackingStore.h	231	Modules/indexeddb/server/SQLiteIDBBackingStore.h
229	Modules/indexeddb/server/ServerOpenDBRequest.h	232	Modules/indexeddb/server/ServerOpenDBRequest.h
230	Modules/indexeddb/server/UniqueIDBDatabase.h	233	Modules/indexeddb/server/UniqueIDBDatabase.h
231	Modules/indexeddb/server/UniqueIDBDatabaseConnection.h	234	Modules/indexeddb/server/UniqueIDBDatabaseConnection.h
		235	Modules/indexeddb/server/UniqueIDBDatabaseManager.h
232	Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h	236	Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h
233		237
234	Modules/indexeddb/shared/IndexKey.h	238	Modules/indexeddb/shared/IndexKey.h

Lines 74-84 public: a/Source/WebCore/Modules/indexeddb/server/IDBConnectionToClient.h_sec1
- a/Source/WebCore/Modules/indexeddb/server/IDBConnectionToClient.h -2 / +2 lines
74		74
75	void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);	75	void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
76		76
77	void didGetAllDatabaseNamesAndVersions(const IDBResourceIdentifier&, Vector<IDBDatabaseNameAndVersion>&&);	77	WEBCORE_EXPORT void didGetAllDatabaseNamesAndVersions(const IDBResourceIdentifier&, Vector<IDBDatabaseNameAndVersion>&&);
78		78
79	void registerDatabaseConnection(UniqueIDBDatabaseConnection&);	79	void registerDatabaseConnection(UniqueIDBDatabaseConnection&);
80	void unregisterDatabaseConnection(UniqueIDBDatabaseConnection&);	80	void unregisterDatabaseConnection(UniqueIDBDatabaseConnection&);
81	void connectionToClientClosed();	81	WEBCORE_EXPORT void connectionToClientClosed();
82	bool isClosed() { return m_isClosed; }	82	bool isClosed() { return m_isClosed; }
83	void clearDelegate() { m_delegate = nullptr; }	83	void clearDelegate() { m_delegate = nullptr; }
84		84

Lines 101-113 void IDBServer::unregisterTransaction(UniqueIDBDatabaseTransaction& transaction) a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp -18 / +24 lines
101	m_transactions.remove(transaction.info().identifier());	101	m_transactions.remove(transaction.info().identifier());
102	}	102	}
103		103
104	void IDBServer::registerDatabaseConnection(UniqueIDBDatabaseConnection& connection)	104	void IDBServer::registerConnection(UniqueIDBDatabaseConnection& connection)
105	{	105	{
106	ASSERT(!m_databaseConnections.contains(connection.identifier()));	106	ASSERT(!m_databaseConnections.contains(connection.identifier()));
107	m_databaseConnections.set(connection.identifier(), &connection);	107	m_databaseConnections.set(connection.identifier(), &connection);
108	}	108	}
109		109
110	void IDBServer::unregisterDatabaseConnection(UniqueIDBDatabaseConnection& connection)	110	void IDBServer::unregisterConnection(UniqueIDBDatabaseConnection& connection)
111	{	111	{
112	ASSERT(m_databaseConnections.contains(connection.identifier()));	112	ASSERT(m_databaseConnections.contains(connection.identifier()));
113	m_databaseConnections.remove(connection.identifier());	113	m_databaseConnections.remove(connection.identifier());
Lines 128-140 std::unique_ptr<IDBBackingStore> IDBServer::createBackingStore(const IDBDatabase a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp_sec2
128	{	128	{
129	ASSERT(!isMainThread());	129	ASSERT(!isMainThread());
130	if (m_databaseDirectoryPath.isEmpty())	130	if (m_databaseDirectoryPath.isEmpty())
131	return makeUnique<MemoryIDBBackingStore>(m_sessionID, identifier);	131	return makeUnique<MemoryIDBBackingStore>(identifier);
132		132
133	ASSERT(!m_sessionID.isEphemeral());	133	ASSERT(!m_sessionID.isEphemeral());
134	if (identifier.isTransient())	134	if (identifier.isTransient())
135	return makeUnique<MemoryIDBBackingStore>(m_sessionID, identifier);	135	return makeUnique<MemoryIDBBackingStore>(identifier);
136		136
137	return makeUnique<SQLiteIDBBackingStore>(m_sessionID, identifier, m_databaseDirectoryPath);	137	return makeUnique<SQLiteIDBBackingStore>(identifier, upgradedDatabaseDirectory(identifier));
138	}	138	}
139		139
140	void IDBServer::openDatabase(const IDBRequestData& requestData)	140	void IDBServer::openDatabase(const IDBRequestData& requestData)
Lines 177-193 void IDBServer::deleteDatabase(const IDBRequestData& requestData) a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp_sec3
177	m_uniqueIDBDatabaseMap.remove(database->identifier());	177	m_uniqueIDBDatabaseMap.remove(database->identifier());
178	}	178	}
179		179
180	std::unique_ptr<UniqueIDBDatabase> IDBServer::closeAndTakeUniqueIDBDatabase(UniqueIDBDatabase& database)
181	{
182	LOG(IndexedDB, "IDBServer::closeUniqueIDBDatabase");
183	ASSERT(isMainThread());
184
185	auto uniquePointer = m_uniqueIDBDatabaseMap.take(database.identifier());
186	ASSERT(uniquePointer);
187
188	return uniquePointer;
189	}
190
191	void IDBServer::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)	180	void IDBServer::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
192	{	181	{
193	LOG(IndexedDB, "IDBServer::abortTransaction");	182	LOG(IndexedDB, "IDBServer::abortTransaction");
Lines 750-756 void IDBServer::renameOrigin(const WebCore::SecurityOriginData& oldOrigin, const a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp_sec4
750	FileSystem::moveFile(oldOriginPath, newOriginPath);	739	FileSystem::moveFile(oldOriginPath, newOriginPath);
751	}	740	}
752		741
753	StorageQuotaManager::Decision IDBServer::requestSpace(const ClientOrigin& origin, uint64_t taskSize) WTF_IGNORES_THREAD_SAFETY_ANALYSIS	742	void IDBServer::requestSpace(const ClientOrigin& origin, uint64_t taskSize, CompletionHandler<void(bool)>&& completionHandler) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
754	{	743	{
755	ASSERT(!isMainThread());	744	ASSERT(!isMainThread());
756	ASSERT(m_lock.isHeld());	745	ASSERT(m_lock.isHeld());
Lines 762-768 StorageQuotaManager::Decision IDBServer::requestSpace(const ClientOrigin& origin a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp_sec5
762	result = m_spaceRequester(origin, taskSize);	751	result = m_spaceRequester(origin, taskSize);
763	m_lock.lock();	752	m_lock.lock();
764		753
765	return result;	754	completionHandler(result == StorageQuotaManager::Decision::Grant);
766	}	755	}
767		756
768	uint64_t IDBServer::diskUsage(const String& rootDirectory, const ClientOrigin& origin)	757	uint64_t IDBServer::diskUsage(const String& rootDirectory, const ClientOrigin& origin)
Lines 784-789 void IDBServer::upgradeFilesIfNecessary() a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp_sec6
784	FileSystem::makeAllDirectories(newVersionDirectory);	773	FileSystem::makeAllDirectories(newVersionDirectory);
785	}	774	}
786		775
		776	String IDBServer::upgradedDatabaseDirectory(const WebCore::IDBDatabaseIdentifier& identifier)
		777	{
		778	String oldOriginDirectory = identifier.databaseDirectoryRelativeToRoot(m_databaseDirectoryPath, "v0");
		779	String oldDatabaseDirectory = FileSystem::pathByAppendingComponent(oldOriginDirectory, SQLiteIDBBackingStore::encodeDatabaseName(identifier.databaseName()));
		780	String newOriginDirectory = identifier.databaseDirectoryRelativeToRoot(m_databaseDirectoryPath, "v1");
		781	String fileNameHash = SQLiteFileSystem::computeHashForFileName(identifier.databaseName());
		782	String newDatabaseDirectory = FileSystem::pathByAppendingComponent(newOriginDirectory, fileNameHash);
		783	FileSystem::makeAllDirectories(newDatabaseDirectory);
		784
		785	if (FileSystem::fileExists(oldDatabaseDirectory)) {
		786	FileSystem::moveFile(oldDatabaseDirectory, newDatabaseDirectory);
		787	FileSystem::deleteEmptyDirectory(oldOriginDirectory);
		788	}
		789
		790	return newDatabaseDirectory;
		791	}
		792
787	bool IDBServer::hasDatabaseActivitiesOnMainThread() const	793	bool IDBServer::hasDatabaseActivitiesOnMainThread() const
788	{	794	{
789	ASSERT(isMainThread());	795	ASSERT(isMainThread());

Lines 44-52 namespace IDBServer { a/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.cpp -3 / +2 lines
44	// The IndexedDB spec states the maximum value you can get from the key generator is 2^53.	44	// The IndexedDB spec states the maximum value you can get from the key generator is 2^53.
45	constexpr uint64_t maxGeneratedKeyValue = 0x20000000000000;	45	constexpr uint64_t maxGeneratedKeyValue = 0x20000000000000;
46		46
47	MemoryIDBBackingStore::MemoryIDBBackingStore(PAL::SessionID sessionID, const IDBDatabaseIdentifier& identifier)	47	MemoryIDBBackingStore::MemoryIDBBackingStore(const IDBDatabaseIdentifier& identifier)
48	: m_identifier(identifier)	48	: m_identifier(identifier)
49	, m_sessionID(sessionID)
50	{	49	{
51	}	50	}
52		51
Lines 134-140 IDBError MemoryIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t a/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.cpp_sec2
134	return IDBError { ConstraintError };	133	return IDBError { ConstraintError };
135		134
136	ASSERT(!m_objectStoresByIdentifier.contains(info.identifier()));	135	ASSERT(!m_objectStoresByIdentifier.contains(info.identifier()));
137	auto objectStore = MemoryObjectStore::create(m_sessionID, info);	136	auto objectStore = MemoryObjectStore::create(info);
138		137
139	m_databaseInfo->addExistingObjectStore(info);	138	m_databaseInfo->addExistingObjectStore(info);
140		139

Lines 30-36 a/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.h_sec1
- a/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.h -4 / +2 lines
30	#include "IDBResourceIdentifier.h"	30	#include "IDBResourceIdentifier.h"
31	#include "IndexKey.h"	31	#include "IndexKey.h"
32	#include "MemoryBackingStoreTransaction.h"	32	#include "MemoryBackingStoreTransaction.h"
33	#include <pal/SessionID.h>
34	#include <wtf/HashMap.h>	33	#include <wtf/HashMap.h>
35		34
36	namespace WebCore {	35	namespace WebCore {
Lines 41-48 class MemoryObjectStore; a/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.h_sec2
41	class MemoryIDBBackingStore final : public IDBBackingStore {	40	class MemoryIDBBackingStore final : public IDBBackingStore {
42	WTF_MAKE_FAST_ALLOCATED;	41	WTF_MAKE_FAST_ALLOCATED;
43	public:	42	public:
44	MemoryIDBBackingStore(PAL::SessionID, const IDBDatabaseIdentifier&);	43	WEBCORE_EXPORT MemoryIDBBackingStore(const IDBDatabaseIdentifier&);
45	~MemoryIDBBackingStore();	44	WEBCORE_EXPORT ~MemoryIDBBackingStore();
46		45
47	IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;	46	IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;
48	uint64_t databaseVersion() final;	47	uint64_t databaseVersion() final;
Lines 92-98 private: a/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.h_sec3
92	void unregisterObjectStore(MemoryObjectStore&);	91	void unregisterObjectStore(MemoryObjectStore&);
93		92
94	IDBDatabaseIdentifier m_identifier;	93	IDBDatabaseIdentifier m_identifier;
95	PAL::SessionID m_sessionID;
96	std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;	94	std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;
97		95
98	HashMap<IDBResourceIdentifier, std::unique_ptr<MemoryBackingStoreTransaction>> m_transactions;	96	HashMap<IDBResourceIdentifier, std::unique_ptr<MemoryBackingStoreTransaction>> m_transactions;

Lines 38-55 a/Source/WebCore/Modules/indexeddb/server/MemoryObjectStore.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/MemoryObjectStore.cpp -4 / +3 lines
38	#include <JavaScriptCore/JSCJSValue.h>	38	#include <JavaScriptCore/JSCJSValue.h>
39	#include <JavaScriptCore/JSCJSValueInlines.h>	39	#include <JavaScriptCore/JSCJSValueInlines.h>
40	#include <JavaScriptCore/JSLock.h>	40	#include <JavaScriptCore/JSLock.h>
41	#include <pal/SessionID.h>
42		41
43	namespace WebCore {	42	namespace WebCore {
44	using namespace JSC;	43	using namespace JSC;
45	namespace IDBServer {	44	namespace IDBServer {
46		45
47	Ref<MemoryObjectStore> MemoryObjectStore::create(PAL::SessionID sessionID, const IDBObjectStoreInfo& info)	46	Ref<MemoryObjectStore> MemoryObjectStore::create(const IDBObjectStoreInfo& info)
48	{	47	{
49	return adoptRef(*new MemoryObjectStore(sessionID, info));	48	return adoptRef(*new MemoryObjectStore(info));
50	}	49	}
51		50
52	MemoryObjectStore::MemoryObjectStore(PAL::SessionID, const IDBObjectStoreInfo& info)	51	MemoryObjectStore::MemoryObjectStore(const IDBObjectStoreInfo& info)
53	: m_info(info)	52	: m_info(info)
54	{	53	{
55	}	54	}

Lines 524-537 void Caches::requestSpace(uint64_t spaceRequired, WebCore::DOMCacheEngine::Compl a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp_sec1
- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp -8 / +4 lines
524	return;	524	return;
525	}	525	}
526		526
527	m_engine->requestSpace(m_origin, spaceRequired, [callback = WTFMove(callback)](auto decision) mutable {	527	m_engine->requestSpace(m_origin, spaceRequired, [callback = WTFMove(callback)](bool granted) mutable {
528	switch (decision) {	528	if (!granted)
529	case WebCore::StorageQuotaManager::Decision::Deny:	529	return callback(Error::QuotaExceeded);
530	callback(Error::QuotaExceeded);	530	callback({ });
531	return;
532	case WebCore::StorageQuotaManager::Decision::Grant:
533	callback({ });
534	};
535	});	531	});
536	}	532	}
537		533

Lines 236-247 static ASCIILiteral indexInfoTableSchemaTemp() a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp -33 / +23 lines
236	return TABLE_SCHEMA_PREFIX "_Temp_IndexInfo" INDEX_INFO_TABLE_SCHEMA_SUFFIX;	236	return TABLE_SCHEMA_PREFIX "_Temp_IndexInfo" INDEX_INFO_TABLE_SCHEMA_SUFFIX;
237	}	237	}
238		238
239	SQLiteIDBBackingStore::SQLiteIDBBackingStore(PAL::SessionID sessionID, const IDBDatabaseIdentifier& identifier, const String& databaseRootDirectory)	239	SQLiteIDBBackingStore::SQLiteIDBBackingStore(const IDBDatabaseIdentifier& identifier, const String& databaseDirectory)
240	: m_sessionID(sessionID)	240	: m_identifier(identifier)
241	, m_identifier(identifier)	241	, m_databaseDirectory(databaseDirectory)
242	, m_databaseRootDirectory(databaseRootDirectory)
243	{	242	{
244	m_databaseDirectory = fullDatabaseDirectoryWithUpgrade();
245	}	243	}
246		244
247	SQLiteIDBBackingStore::~SQLiteIDBBackingStore()	245	SQLiteIDBBackingStore::~SQLiteIDBBackingStore()
Lines 912-930 std::unique_ptr<IDBDatabaseInfo> SQLiteIDBBackingStore::extractExistingDatabaseI a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec2
912	return databaseInfo;	910	return databaseInfo;
913	}	911	}
914		912
915	String SQLiteIDBBackingStore::filenameForDatabaseName() const	913	String SQLiteIDBBackingStore::encodeDatabaseName(const String& databaseName)
916	{	914	{
917	ASSERT(!m_identifier.databaseName().isNull());	915	ASSERT(!databaseName.isNull());
918		916	if (databaseName.isEmpty())
919	if (m_identifier.databaseName().isEmpty())
920	return "%00";	917	return "%00";
921		918
922	String filename = FileSystem::encodeForFileName(m_identifier.databaseName());	919	String filename = FileSystem::encodeForFileName(databaseName);
923	filename.replace('.', "%2E");	920	filename.replace('.', "%2E");
924		921
925	return filename;	922	return filename;
926	}	923	}
927		924
		925	String SQLiteIDBBackingStore::decodeDatabaseName(const String& encodedName)
		926	{
		927	if (encodedName == "%00"_s)
		928	return { };
		929
		930	String name = encodedName;
		931	name.replace("%2E"_s, "."_s);
		932
		933	return FileSystem::decodeFromFilename(name);
		934	}
		935
928	String SQLiteIDBBackingStore::fullDatabasePathForDirectory(const String& fullDatabaseDirectory)	936	String SQLiteIDBBackingStore::fullDatabasePathForDirectory(const String& fullDatabaseDirectory)
929	{	937	{
930	return FileSystem::pathByAppendingComponent(fullDatabaseDirectory, "IndexedDB.sqlite3");	938	return FileSystem::pathByAppendingComponent(fullDatabaseDirectory, "IndexedDB.sqlite3");
Lines 965-987 std::optional<IDBDatabaseNameAndVersion> SQLiteIDBBackingStore::databaseNameAndV a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec3
965	return IDBDatabaseNameAndVersion { databaseName, *databaseVersion };	973	return IDBDatabaseNameAndVersion { databaseName, *databaseVersion };
966	}	974	}
967		975
968	String SQLiteIDBBackingStore::fullDatabaseDirectoryWithUpgrade()
969	{
970	String oldOriginDirectory = m_identifier.databaseDirectoryRelativeToRoot(m_databaseRootDirectory, "v0");
971	String oldDatabaseDirectory = FileSystem::pathByAppendingComponent(oldOriginDirectory, filenameForDatabaseName());
972	String newOriginDirectory = m_identifier.databaseDirectoryRelativeToRoot(m_databaseRootDirectory, "v1");
973	String fileNameHash = SQLiteFileSystem::computeHashForFileName(m_identifier.databaseName());
974	String newDatabaseDirectory = FileSystem::pathByAppendingComponent(newOriginDirectory, fileNameHash);
975	FileSystem::makeAllDirectories(newDatabaseDirectory);
976
977	if (FileSystem::fileExists(oldDatabaseDirectory)) {
978	FileSystem::moveFile(oldDatabaseDirectory, newDatabaseDirectory);
979	FileSystem::deleteEmptyDirectory(oldOriginDirectory);
980	}
981
982	return newDatabaseDirectory;
983	}
984
985	IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info)	976	IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info)
986	{	977	{
987	LOG(IndexedDB, "SQLiteIDBBackingStore::getOrEstablishDatabaseInfo - database %s", m_identifier.databaseName().utf8().data());	978	LOG(IndexedDB, "SQLiteIDBBackingStore::getOrEstablishDatabaseInfo - database %s", m_identifier.databaseName().utf8().data());
Lines 991-1001 IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec4
991	return IDBError { };	982	return IDBError { };
992	}	983	}
993		984
994	String dbFilename = fullDatabasePath();	985	String databasePath = fullDatabasePath();
995		986	FileSystem::makeAllDirectories(FileSystem::parentPath(databasePath));
996	m_sqliteDB = makeUnique<SQLiteDatabase>();	987	m_sqliteDB = makeUnique<SQLiteDatabase>();
997	if (!m_sqliteDB->open(dbFilename)) {	988	if (!m_sqliteDB->open(databasePath)) {
998	LOG_ERROR("Failed to open SQLite database at path '%s'", dbFilename.utf8().data());	989	LOG_ERROR("Failed to open SQLite database at path '%s'", databasePath.utf8().data());
999	closeSQLiteDB();	990	closeSQLiteDB();
1000	}	991	}
1001		992
Lines 1044-1050 IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec5
1044	databaseInfo = createAndPopulateInitialDatabaseInfo();	1035	databaseInfo = createAndPopulateInitialDatabaseInfo();
1045		1036
1046	if (!databaseInfo) {	1037	if (!databaseInfo) {
1047	LOG_ERROR("Unable to establish IDB database at path '%s'", dbFilename.utf8().data());	1038	LOG_ERROR("Unable to establish IDB database at path '%s'", databasePath.utf8().data());
1048	closeSQLiteDB();	1039	closeSQLiteDB();
1049	return IDBError { UnknownError, "Unable to establish IDB database file"_s };	1040	return IDBError { UnknownError, "Unable to establish IDB database file"_s };
1050	}	1041	}
Lines 2798-2804 void SQLiteIDBBackingStore::deleteBackingStore() a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec6
2798		2789
2799	SQLiteFileSystem::deleteDatabaseFile(databasePath);	2790	SQLiteFileSystem::deleteDatabaseFile(databasePath);
2800	SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_databaseDirectory);	2791	SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_databaseDirectory);
2801	SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_identifier.databaseDirectoryRelativeToRoot(m_databaseRootDirectory));
2802	}	2792	}
2803		2793
2804	void SQLiteIDBBackingStore::unregisterCursor(SQLiteIDBCursor& cursor)	2794	void SQLiteIDBBackingStore::unregisterCursor(SQLiteIDBCursor& cursor)

Lines 51-59 class SQLiteIDBCursor; a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h_sec1
- a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h -13 / +7 lines
51	class SQLiteIDBBackingStore final : public IDBBackingStore {	51	class SQLiteIDBBackingStore final : public IDBBackingStore {
52	WTF_MAKE_FAST_ALLOCATED;	52	WTF_MAKE_FAST_ALLOCATED;
53	public:	53	public:
54	SQLiteIDBBackingStore(PAL::SessionID, const IDBDatabaseIdentifier&, const String& databaseRootDirectory);	54	WEBCORE_EXPORT SQLiteIDBBackingStore(const IDBDatabaseIdentifier&, const String& databaseDirectory);
55		55	WEBCORE_EXPORT ~SQLiteIDBBackingStore() final;
56	~SQLiteIDBBackingStore() final;
57		56
58	IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;	57	IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;
59	uint64_t databaseVersion() final;	58	uint64_t databaseVersion() final;
Lines 94-111 public: a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h_sec2
94		93
95	IDBError getBlobRecordsForObjectStoreRecord(int64_t objectStoreRecord, Vector<String>& blobURLs, Vector<String>& blobFilePaths);	94	IDBError getBlobRecordsForObjectStoreRecord(int64_t objectStoreRecord, Vector<String>& blobURLs, Vector<String>& blobFilePaths);
96		95
97	static uint64_t databasesSizeForDirectory(const String& directory);	96	WEBCORE_EXPORT static uint64_t databasesSizeForDirectory(const String& directory);
98
99	String databaseDirectory() const { return m_databaseDirectory; };	97	String databaseDirectory() const { return m_databaseDirectory; };
100	static String fullDatabasePathForDirectory(const String&);	98	WEBCORE_EXPORT static String fullDatabasePathForDirectory(const String&);
101	static std::optional<IDBDatabaseNameAndVersion> databaseNameAndVersionFromFile(const String&);	99	WEBCORE_EXPORT static String encodeDatabaseName(const String& databaseName);
		100	WEBCORE_EXPORT static String decodeDatabaseName(const String& encodedDatabaseName);
102		101
103	PAL::SessionID sessionID() const { return m_sessionID; }	102	WEBCORE_EXPORT static std::optional<IDBDatabaseNameAndVersion> databaseNameAndVersionFromFile(const String&);
104		103
105	private:	104	private:
106	String filenameForDatabaseName() const;
107	String fullDatabaseDirectoryWithUpgrade();
108
109	IDBError ensureValidRecordsTable();	105	IDBError ensureValidRecordsTable();
110	IDBError ensureValidIndexRecordsTable();	106	IDBError ensureValidIndexRecordsTable();
111	IDBError ensureValidIndexRecordsIndex();	107	IDBError ensureValidIndexRecordsIndex();
Lines 206-212 private: a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h_sec3
206		202
207	std::unique_ptr<SQLiteStatement> m_cachedStatements[static_cast<int>(SQL::Invalid)];	203	std::unique_ptr<SQLiteStatement> m_cachedStatements[static_cast<int>(SQL::Invalid)];
208		204
209	PAL::SessionID m_sessionID;
210	IDBDatabaseIdentifier m_identifier;	205	IDBDatabaseIdentifier m_identifier;
211	std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;	206	std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;
212	std::unique_ptr<IDBDatabaseInfo> m_originalDatabaseInfoBeforeVersionChange;	207	std::unique_ptr<IDBDatabaseInfo> m_originalDatabaseInfoBeforeVersionChange;
Lines 216-222 private: a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h_sec4
216	HashMap<IDBResourceIdentifier, std::unique_ptr<SQLiteIDBTransaction>> m_transactions;	211	HashMap<IDBResourceIdentifier, std::unique_ptr<SQLiteIDBTransaction>> m_transactions;
217	HashMap<IDBResourceIdentifier, SQLiteIDBCursor*> m_cursors;	212	HashMap<IDBResourceIdentifier, SQLiteIDBCursor*> m_cursors;
218		213
219	String m_databaseRootDirectory;
220	String m_databaseDirectory;	214	String m_databaseDirectory;
221	};	215	};
222		216

Lines 25-31 a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h_sec1
- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h -8 / +8 lines
25		25
26	#pragma once	26	#pragma once
27		27
28	#include "IDBServer.h"
29	#include "UniqueIDBDatabase.h"	28	#include "UniqueIDBDatabase.h"
30	#include <wtf/HashMap.h>	29	#include <wtf/HashMap.h>
31	#include <wtf/Identified.h>	30	#include <wtf/Identified.h>
Lines 36-41 namespace WebCore { a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h_sec2
36		35
37	class IDBError;	36	class IDBError;
38	class IDBResultData;	37	class IDBResultData;
		38	class UniqueIDBDatabaseManager;
39		39
40	namespace IDBServer {	40	namespace IDBServer {
41		41
Lines 52-62 public: a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h_sec3
52		52
53	const IDBResourceIdentifier& openRequestIdentifier() { return m_openRequestIdentifier; }	53	const IDBResourceIdentifier& openRequestIdentifier() { return m_openRequestIdentifier; }
54	UniqueIDBDatabase* database() { return m_database.get(); }	54	UniqueIDBDatabase* database() { return m_database.get(); }
55	IDBServer* server() { return &m_server; }	55	UniqueIDBDatabaseManager* manager();
56	IDBConnectionToClient& connectionToClient() { return m_connectionToClient; }	56	IDBConnectionToClient& connectionToClient() { return m_connectionToClient; }
57		57
58	void connectionPendingCloseFromClient();	58	WEBCORE_EXPORT void connectionPendingCloseFromClient();
59	void connectionClosedFromClient();	59	WEBCORE_EXPORT void connectionClosedFromClient();
60		60
61	bool closePending() const { return m_closePending; }	61	bool closePending() const { return m_closePending; }
62		62
Lines 65-71 public: a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h_sec4
65	void fireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion);	65	void fireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion);
66	UniqueIDBDatabaseTransaction& createVersionChangeTransaction(uint64_t newVersion);	66	UniqueIDBDatabaseTransaction& createVersionChangeTransaction(uint64_t newVersion);
67		67
68	void establishTransaction(const IDBTransactionInfo&);	68	WEBCORE_EXPORT void establishTransaction(const IDBTransactionInfo&);
69	void didAbortTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);	69	void didAbortTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);
70	void didCommitTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);	70	void didCommitTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);
71	void didCreateObjectStore(const IDBResultData&);	71	void didCreateObjectStore(const IDBResultData&);
Lines 75-82 public: a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h_sec5
75	void didCreateIndex(const IDBResultData&);	75	void didCreateIndex(const IDBResultData&);
76	void didDeleteIndex(const IDBResultData&);	76	void didDeleteIndex(const IDBResultData&);
77	void didRenameIndex(const IDBResultData&);	77	void didRenameIndex(const IDBResultData&);
78	void didFireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, IndexedDB::ConnectionClosedOnBehalfOfServer);	78	WEBCORE_EXPORT void didFireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, IndexedDB::ConnectionClosedOnBehalfOfServer);
79	void didFinishHandlingVersionChange(const IDBResourceIdentifier& transactionIdentifier);	79	WEBCORE_EXPORT void didFinishHandlingVersionChange(const IDBResourceIdentifier& transactionIdentifier);
80		80
81	void abortTransactionWithoutCallback(UniqueIDBDatabaseTransaction&);	81	void abortTransactionWithoutCallback(UniqueIDBDatabaseTransaction&);
82		82
Lines 88-94 private: a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h_sec6
88	UniqueIDBDatabaseConnection(UniqueIDBDatabase&, ServerOpenDBRequest&);	88	UniqueIDBDatabaseConnection(UniqueIDBDatabase&, ServerOpenDBRequest&);
89		89
90	WeakPtr<UniqueIDBDatabase> m_database;	90	WeakPtr<UniqueIDBDatabase> m_database;
91	IDBServer& m_server;	91	WeakPtr<UniqueIDBDatabaseManager> m_manager;
92	Ref<IDBConnectionToClient> m_connectionToClient;	92	Ref<IDBConnectionToClient> m_connectionToClient;
93	IDBResourceIdentifier m_openRequestIdentifier;	93	IDBResourceIdentifier m_openRequestIdentifier;
94		94

Line 0 a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseManager.h_sec1
- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseManager.h +54 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 "IDBDatabaseIdentifier.h"
	29
	30	namespace WebCore {
	31
	32	struct ClientOrigin;
	33
	34	namespace IDBServer {
	35
	36	class IDBBackingStore;
	37	class UniqueIDBDatabaseConnection;
	38	class UniqueIDBDatabaseTransaction;
	39
	40	class UniqueIDBDatabaseManager : public CanMakeWeakPtr<UniqueIDBDatabaseManager> {
	41	WTF_MAKE_FAST_ALLOCATED;
	42	public:
	43	virtual ~UniqueIDBDatabaseManager() { }
	44	virtual void registerConnection(UniqueIDBDatabaseConnection&) = 0;
	45	virtual void unregisterConnection(UniqueIDBDatabaseConnection&) = 0;
	46	virtual void registerTransaction(UniqueIDBDatabaseTransaction&) = 0;
	47	virtual void unregisterTransaction(UniqueIDBDatabaseTransaction&) = 0;
	48	virtual std::unique_ptr<IDBBackingStore> createBackingStore(const IDBDatabaseIdentifier&) = 0;
	49	virtual void requestSpace(const ClientOrigin&, uint64_t size, CompletionHandler<void(bool)>&&) = 0;
	50	};
	51
	52	} // namespace IDBServer
	53
	54	} // namespace WebCore

Lines 28-34 a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp -3 / +4 lines
28		28
29	#include "IDBIterateCursorData.h"	29	#include "IDBIterateCursorData.h"
30	#include "IDBResultData.h"	30	#include "IDBResultData.h"
31	#include "IDBServer.h"
32	#include "Logging.h"	31	#include "Logging.h"
33	#include "UniqueIDBDatabase.h"	32	#include "UniqueIDBDatabase.h"
34		33
Lines 50-61 UniqueIDBDatabaseTransaction::UniqueIDBDatabaseTransaction(UniqueIDBDatabaseConn a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp_sec2
50	if (m_transactionInfo.mode() == IDBTransactionMode::Versionchange)	49	if (m_transactionInfo.mode() == IDBTransactionMode::Versionchange)
51	m_originalDatabaseInfo = makeUnique<IDBDatabaseInfo>(database->info());	50	m_originalDatabaseInfo = makeUnique<IDBDatabaseInfo>(database->info());
52		51
53	databaseConnection().server()->registerTransaction(*this);	52	if (auto* manager = databaseConnection().manager())
		53	manager->registerTransaction(*this);
54	}	54	}
55		55
56	UniqueIDBDatabaseTransaction::~UniqueIDBDatabaseTransaction()	56	UniqueIDBDatabaseTransaction::~UniqueIDBDatabaseTransaction()
57	{	57	{
58	databaseConnection().server()->unregisterTransaction(*this);	58	if (auto* manager = databaseConnection().manager())
		59	manager->unregisterTransaction(*this);
59	}	60	}
60		61
61	UniqueIDBDatabaseConnection& UniqueIDBDatabaseTransaction::databaseConnection()	62	UniqueIDBDatabaseConnection& UniqueIDBDatabaseTransaction::databaseConnection()

Lines 51-57 namespace IDBServer { a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h_sec1
- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h -20 / +20 lines
51	class IDBServer;	51	class IDBServer;
52	class UniqueIDBDatabaseConnection;	52	class UniqueIDBDatabaseConnection;
53		53
54	class UniqueIDBDatabaseTransaction : public RefCounted<UniqueIDBDatabaseTransaction> {	54	class UniqueIDBDatabaseTransaction : public CanMakeWeakPtr<UniqueIDBDatabaseTransaction>, public RefCounted<UniqueIDBDatabaseTransaction> {
55	public:	55	public:
56	static Ref<UniqueIDBDatabaseTransaction> create(UniqueIDBDatabaseConnection&, const IDBTransactionInfo&);	56	static Ref<UniqueIDBDatabaseTransaction> create(UniqueIDBDatabaseConnection&, const IDBTransactionInfo&);
57		57
Lines 59-87 public: a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h_sec2
59		59
60	UniqueIDBDatabaseConnection& databaseConnection();	60	UniqueIDBDatabaseConnection& databaseConnection();
61	const IDBTransactionInfo& info() const { return m_transactionInfo; }	61	const IDBTransactionInfo& info() const { return m_transactionInfo; }
62	bool isVersionChange() const;	62	WEBCORE_EXPORT bool isVersionChange() const;
63	bool isReadOnly() const;	63	bool isReadOnly() const;
64		64
65	IDBDatabaseInfo* originalDatabaseInfo() const;	65	IDBDatabaseInfo* originalDatabaseInfo() const;
66		66
67	void abort();	67	WEBCORE_EXPORT void abort();
68	void abortWithoutCallback();	68	WEBCORE_EXPORT void abortWithoutCallback();
69	void commit(uint64_t pendingRequestCount);	69	WEBCORE_EXPORT void commit(uint64_t pendingRequestCount);
70		70
71	void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&);	71	WEBCORE_EXPORT void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&);
72	void deleteObjectStore(const IDBRequestData&, const String& objectStoreName);	72	WEBCORE_EXPORT void deleteObjectStore(const IDBRequestData&, const String& objectStoreName);
73	void renameObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);	73	WEBCORE_EXPORT void renameObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);
74	void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier);	74	WEBCORE_EXPORT void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier);
75	void createIndex(const IDBRequestData&, const IDBIndexInfo&);	75	WEBCORE_EXPORT void createIndex(const IDBRequestData&, const IDBIndexInfo&);
76	void deleteIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);	76	WEBCORE_EXPORT void deleteIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);
77	void renameIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);	77	WEBCORE_EXPORT void renameIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);
78	void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode);	78	WEBCORE_EXPORT void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode);
79	void getRecord(const IDBRequestData&, const IDBGetRecordData&);	79	WEBCORE_EXPORT void getRecord(const IDBRequestData&, const IDBGetRecordData&);
80	void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&);	80	WEBCORE_EXPORT void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&);
81	void getCount(const IDBRequestData&, const IDBKeyRangeData&);	81	WEBCORE_EXPORT void getCount(const IDBRequestData&, const IDBKeyRangeData&);
82	void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&);	82	WEBCORE_EXPORT void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&);
83	void openCursor(const IDBRequestData&, const IDBCursorInfo&);	83	WEBCORE_EXPORT void openCursor(const IDBRequestData&, const IDBCursorInfo&);
84	void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&);	84	WEBCORE_EXPORT void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&);
85		85
86	void didActivateInBackingStore(const IDBError&);	86	void didActivateInBackingStore(const IDBError&);
87		87

Lines 56-63 public: a/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.h_sec1
- a/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.h -2 / +2 lines
56	WEBCORE_EXPORT IDBRequestData isolatedCopy() const;	56	WEBCORE_EXPORT IDBRequestData isolatedCopy() const;
57		57
58	IDBConnectionIdentifier serverConnectionIdentifier() const;	58	IDBConnectionIdentifier serverConnectionIdentifier() const;
59	IDBResourceIdentifier requestIdentifier() const;	59	WEBCORE_EXPORT IDBResourceIdentifier requestIdentifier() const;
60	IDBResourceIdentifier transactionIdentifier() const;	60	WEBCORE_EXPORT IDBResourceIdentifier transactionIdentifier() const;
61	uint64_t objectStoreIdentifier() const;	61	uint64_t objectStoreIdentifier() const;
62	uint64_t indexIdentifier() const;	62	uint64_t indexIdentifier() const;
63	IndexedDB::IndexRecordType indexRecordType() const;	63	IndexedDB::IndexRecordType indexRecordType() const;

Lines 49-55 public: a/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h_sec1
- a/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h -2 / +3 lines
49	IDBResourceIdentifier(const IDBClient::IDBConnectionProxy&, const IDBRequest&);	49	IDBResourceIdentifier(const IDBClient::IDBConnectionProxy&, const IDBRequest&);
50	explicit IDBResourceIdentifier(const IDBServer::IDBConnectionToClient&);	50	explicit IDBResourceIdentifier(const IDBServer::IDBConnectionToClient&);
51		51
52	static IDBResourceIdentifier emptyValue();	52	WEBCORE_EXPORT static IDBResourceIdentifier emptyValue();
53	bool isEmpty() const	53	bool isEmpty() const
54	{	54	{
55	return !m_resourceNumber && !m_idbConnectionIdentifier;	55	return !m_resourceNumber && !m_idbConnectionIdentifier;
Lines 60-66 public: a/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h_sec2
60	uint64_t hashCodes[2] = { m_idbConnectionIdentifier.toUInt64(), m_resourceNumber };	60	uint64_t hashCodes[2] = { m_idbConnectionIdentifier.toUInt64(), m_resourceNumber };
61	return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);	61	return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
62	}	62	}
63		63
		64	bool operator!=(const IDBResourceIdentifier& other) const { return !(*this == other); }
64	bool operator==(const IDBResourceIdentifier& other) const	65	bool operator==(const IDBResourceIdentifier& other) const
65	{	66	{
66	return m_idbConnectionIdentifier == other.m_idbConnectionIdentifier	67	return m_idbConnectionIdentifier == other.m_idbConnectionIdentifier

Lines 52-64 a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp_sec1
- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp -5 / +11 lines
52	#include "NetworkSocketChannelMessages.h"	52	#include "NetworkSocketChannelMessages.h"
53	#include "NetworkSocketStream.h"	53	#include "NetworkSocketStream.h"
54	#include "NetworkSocketStreamMessages.h"	54	#include "NetworkSocketStreamMessages.h"
		55	#include "NetworkStorageManager.h"
55	#include "PingLoad.h"	56	#include "PingLoad.h"
56	#include "PreconnectTask.h"	57	#include "PreconnectTask.h"
57	#include "RTCDataChannelRemoteManagerProxy.h"	58	#include "RTCDataChannelRemoteManagerProxy.h"
58	#include "ServiceWorkerFetchTaskMessages.h"	59	#include "ServiceWorkerFetchTaskMessages.h"
59	#include "WebCoreArgumentCoders.h"	60	#include "WebCoreArgumentCoders.h"
60	#include "WebErrors.h"	61	#include "WebErrors.h"
61	#include "WebIDBServer.h"
62	#include "WebProcessMessages.h"	62	#include "WebProcessMessages.h"
63	#include "WebProcessPoolMessages.h"	63	#include "WebProcessPoolMessages.h"
64	#include "WebResourceLoadStatisticsStore.h"	64	#include "WebResourceLoadStatisticsStore.h"
Lines 390-397 bool NetworkConnectionToWebProcess::didReceiveSyncMessage(IPC::Connection& conne a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp_sec2
390		390
391	void NetworkConnectionToWebProcess::updateQuotaBasedOnSpaceUsageForTesting(const ClientOrigin& origin)	391	void NetworkConnectionToWebProcess::updateQuotaBasedOnSpaceUsageForTesting(const ClientOrigin& origin)
392	{	392	{
393	auto storageQuotaManager = m_networkProcess->storageQuotaManager(sessionID(), origin);	393	auto* session = m_networkProcess->networkSession(sessionID());
394	storageQuotaManager->resetQuotaUpdatedBasedOnUsageForTesting();	394	if (!session)
		395	return;
		396
		397	if (auto* storageManager = session->storageManager())
		398	storageManager->resetQuotaUpdatedBasedOnUsageForTesting(origin);
395	}	399	}
396		400
397	void NetworkConnectionToWebProcess::didClose(IPC::Connection& connection)	401	void NetworkConnectionToWebProcess::didClose(IPC::Connection& connection)
Lines 983-990 void NetworkConnectionToWebProcess::writeBlobsToTemporaryFilesForIndexedDB(const a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp_sec3
983	for (auto& file : fileReferences)	987	for (auto& file : fileReferences)
984	file->revokeFileAccess();	988	file->revokeFileAccess();
985		989
986	if (auto* session = networkSession())	990	if (auto* session = networkSession()) {
987	session->ensureWebIDBServer().registerTemporaryBlobFilePaths(m_connection, filePaths);	991	if (auto* storageManager = session->storageManager())
		992	storageManager->registerTemporaryBlobFilePaths(m_connection, filePaths);
		993	}
988	completionHandler(WTFMove(filePaths));	994	completionHandler(WTFMove(filePaths));
989	});	995	});
990	}	996	}

Lines 264-271 void NetworkProcess::didClose(IPC::Connection&) a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec1
- a/Source/WebKit/NetworkProcess/NetworkProcess.cpp -89 / +19 lines
264	// Make sure we flush all cookies to disk before exiting.	264	// Make sure we flush all cookies to disk before exiting.
265	forEachNetworkSession([&] (auto& session) {	265	forEachNetworkSession([&] (auto& session) {
266	platformFlushCookies(session.sessionID(), [callbackAggregator] { });	266	platformFlushCookies(session.sessionID(), [callbackAggregator] { });
267	// Make sure reference to NetworkProcess in spaceRequester is removed.
268	session.closeIDBServer([callbackAggregator] { });
269	});	267	});
270	}	268	}
271		269
Lines 382-388 void NetworkProcess::createNetworkConnectionToWebProcess(ProcessIdentifier ident a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec2
382	connection.setOnLineState(NetworkStateNotifier::singleton().onLine());	380	connection.setOnLineState(NetworkStateNotifier::singleton().onLine());
383		381
384	if (auto* session = networkSession(sessionID)) {	382	if (auto* session = networkSession(sessionID)) {
385	session->ensureWebIDBServer().addConnection(connection.connection(), identifier);
386	if (auto* manager = session->storageManager())	383	if (auto* manager = session->storageManager())
387	manager->startReceivingMessageFromConnection(connection.connection());	384	manager->startReceivingMessageFromConnection(connection.connection());
388	}	385	}
Lines 406-413 void NetworkProcess::addWebsiteDataStore(WebsiteDataStoreParameters&& parameters a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec3
406	addSessionStorageQuotaManager(sessionID, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota, parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);	403	addSessionStorageQuotaManager(sessionID, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota, parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);
407		404
408	if (auto* session = networkSession(sessionID)) {	405	if (auto* session = networkSession(sessionID)) {
409	session->addStorageManagerSession(parameters.generalStorageDirectory, parameters.generalStorageDirectoryHandle, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle);	406	session->addStorageManagerSession(parameters.generalStorageDirectory, parameters.generalStorageDirectoryHandle, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle, parameters.cacheStorageDirectory, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota);
410	session->addIndexedDatabaseSession(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
411	#if ENABLE(SERVICE_WORKER)	407	#if ENABLE(SERVICE_WORKER)
412	session->addServiceWorkerSession(parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);	408	session->addServiceWorkerSession(parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
413	#endif	409	#endif
Lines 1452-1464 void NetworkProcess::fetchWebsiteData(PAL::SessionID sessionID, OptionSet<Websit a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec4
1452	callbackAggregator->m_websiteData.hostNamesWithHSTSCache = hostNamesWithHSTSCache(sessionID);	1448	callbackAggregator->m_websiteData.hostNamesWithHSTSCache = hostNamesWithHSTSCache(sessionID);
1453	#endif	1449	#endif
1454		1450
1455	if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath()) {
1456	session->ensureWebIDBServer().getOrigins([callbackAggregator](auto&& origins) {
1457	while (!origins.isEmpty())
1458	callbackAggregator->m_websiteData.entries.append({ origins.takeAny(), WebsiteDataType::IndexedDBDatabases, 0 });
1459	});
1460	}
1461
1462	#if ENABLE(SERVICE_WORKER)	1451	#if ENABLE(SERVICE_WORKER)
1463	if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {	1452	if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {
1464	session->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {	1453	session->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {
Lines 1525-1533 void NetworkProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<Websi a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec5
1525	if (websiteDataTypes.contains(WebsiteDataType::DOMCache) && session)	1514	if (websiteDataTypes.contains(WebsiteDataType::DOMCache) && session)
1526	CacheStorage::Engine::clearAllCaches(*session, [clearTasksHandler] { });	1515	CacheStorage::Engine::clearAllCaches(*session, [clearTasksHandler] { });
1527		1516
1528	if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral() && session)
1529	session->ensureWebIDBServer().closeAndDeleteDatabasesModifiedSince(modifiedSince, [clearTasksHandler] { });
1530
1531	#if ENABLE(SERVICE_WORKER)	1517	#if ENABLE(SERVICE_WORKER)
1532	bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) \|\| websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);	1518	bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) \|\| websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
1533	if (clearServiceWorkers && !sessionID.isEphemeral() && session)	1519	if (clearServiceWorkers && !sessionID.isEphemeral() && session)
Lines 1620-1628 void NetworkProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, Optio a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec6
1620	CacheStorage::Engine::clearCachesForOrigin(*session, SecurityOriginData { originData }, [clearTasksHandler] { });	1606	CacheStorage::Engine::clearCachesForOrigin(*session, SecurityOriginData { originData }, [clearTasksHandler] { });
1621	}	1607	}
1622		1608
1623	if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral() && session)
1624	session->ensureWebIDBServer().closeAndDeleteDatabasesForOrigins(originDatas, [clearTasksHandler] { });
1625
1626	#if ENABLE(SERVICE_WORKER)	1609	#if ENABLE(SERVICE_WORKER)
1627	bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) \|\| websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);	1610	bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) \|\| websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
1628	if (clearServiceWorkers && !sessionID.isEphemeral() && session) {	1611	if (clearServiceWorkers && !sessionID.isEphemeral() && session) {
Lines 1811-1827 void NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains(PAL::Sess a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec7
1811	}	1794	}
1812	});	1795	});
1813	}	1796	}
1814
1815	if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath()) {
1816	session->ensureWebIDBServer().getOrigins([this, protectedThis = Ref { *this }, sessionID, callbackAggregator, domainsToDeleteAllNonCookieWebsiteDataFor](auto&& origins) {
1817	auto* session = networkSession(sessionID);
1818	if (!session \|\| !session->webIDBServer())
1819	return;
1820
1821	auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator->m_domains);
1822	session->webIDBServer()->closeAndDeleteDatabasesForOrigins(originsToDelete, [callbackAggregator] { });
1823	});
1824	}
1825		1797
1826	#if ENABLE(SERVICE_WORKER)	1798	#if ENABLE(SERVICE_WORKER)
1827	bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) \|\| websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);	1799	bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) \|\| websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
Lines 1958-1970 void NetworkProcess::registrableDomainsWithWebsiteData(PAL::SessionID sessionID, a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec8
1958	});	1930	});
1959	}	1931	}
1960		1932
1961	if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath()) {
1962	session->ensureWebIDBServer().getOrigins([callbackAggregator](auto&& origins) {
1963	while (!origins.isEmpty())
1964	callbackAggregator->m_websiteData.entries.append({ origins.takeAny(), WebsiteDataType::IndexedDBDatabases, 0 });
1965	});
1966	}
1967
1968	#if ENABLE(SERVICE_WORKER)	1933	#if ENABLE(SERVICE_WORKER)
1969	if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {	1934	if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {
1970	session->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {	1935	session->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {
Lines 2129-2171 void NetworkProcess::processWillSuspendImminentlyForTestingSync(CompletionHandle a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec9
2129	prepareToSuspend(true, WTFMove(completionHandler));	2094	prepareToSuspend(true, WTFMove(completionHandler));
2130	}	2095	}
2131		2096
2132	void NetworkProcess::suspendIDBServers(bool isSuspensionImminent)
2133	{
2134	m_shouldSuspendIDBServers = true;
2135	++m_suspensionIdentifier;
2136
2137	bool allSuspended = true;
2138	auto condition = isSuspensionImminent ? WebIDBServer::SuspensionCondition::Always : WebIDBServer::SuspensionCondition::IfIdle;
2139	forEachNetworkSession([&](auto& session) {
2140	if (auto* server = session.webIDBServer())
2141	allSuspended &= server->suspend(condition);
2142	});
2143
2144	if (allSuspended)
2145	return;
2146
2147	RunLoop::main().dispatchAfter(5_s, [this, weakThis = WeakPtr { *this }, suspensionIdentifier = m_suspensionIdentifier] {
2148	if (!weakThis)
2149	return;
2150
2151	if (!m_shouldSuspendIDBServers \|\| suspensionIdentifier != m_suspensionIdentifier)
2152	return;
2153
2154	forEachNetworkSession([](auto& session) {
2155	if (auto* server = session.webIDBServer())
2156	server->suspend(WebIDBServer::SuspensionCondition::Always);
2157	});
2158	});
2159	}
2160
2161	void NetworkProcess::prepareToSuspend(bool isSuspensionImminent, CompletionHandler<void()>&& completionHandler)	2097	void NetworkProcess::prepareToSuspend(bool isSuspensionImminent, CompletionHandler<void()>&& completionHandler)
2162	{	2098	{
2163	RELEASE_LOG(ProcessSuspension, "%p - NetworkProcess::prepareToSuspend(), isSuspensionImminent=%d", this, isSuspensionImminent);	2099	RELEASE_LOG(ProcessSuspension, "%p - NetworkProcess::prepareToSuspend(), isSuspensionImminent=%d", this, isSuspensionImminent);
2164		2100
2165	#if PLATFORM(IOS_FAMILY)
2166	suspendIDBServers(isSuspensionImminent);
2167	#endif
2168
2169	lowMemoryHandler(Critical::Yes);	2101	lowMemoryHandler(Critical::Yes);
2170		2102
2171	RefPtr<CallbackAggregator> callbackAggregator = CallbackAggregator::create([this, completionHandler = WTFMove(completionHandler)]() mutable {	2103	RefPtr<CallbackAggregator> callbackAggregator = CallbackAggregator::create([this, completionHandler = WTFMove(completionHandler)]() mutable {
Lines 2223-2240 void NetworkProcess::resume() a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec10
2223	#if ENABLE(SERVICE_WORKER)	2155	#if ENABLE(SERVICE_WORKER)
2224	if (auto* swServer = session.swServer())	2156	if (auto* swServer = session.swServer())
2225	swServer->endSuspension();	2157	swServer->endSuspension();
2226	#endif
2227	#if PLATFORM(IOS_FAMILY)
2228	if (auto* server = session.webIDBServer())
2229	server->resume();
2230	#endif	2158	#endif
2231	if (auto* manager = session.storageManager())	2159	if (auto* manager = session.storageManager())
2232	manager->resume();	2160	manager->resume();
2233	});	2161	});
2234
2235	#if PLATFORM(IOS_FAMILY)
2236	m_shouldSuspendIDBServers = false;
2237	#endif
2238	}	2162	}
2239		2163
2240	void NetworkProcess::prefetchDNS(const String& hostname)	2164	void NetworkProcess::prefetchDNS(const String& hostname)
Lines 2281-2292 void NetworkProcess::syncLocalStorage(CompletionHandler<void()>&& completionHand a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec11
2281		2205
2282	void NetworkProcess::resetQuota(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)	2206	void NetworkProcess::resetQuota(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
2283	{	2207	{
2284	Locker locker { m_sessionStorageQuotaManagersLock };	2208	auto* session = networkSession(sessionID);
2285	if (auto* sessionStorageQuotaManager = m_sessionStorageQuotaManagers.get(sessionID)) {	2209	if (!session)
2286	for (auto storageQuotaManager : sessionStorageQuotaManager->existingStorageQuotaManagers())	2210	return completionHandler();
2287	storageQuotaManager->resetQuotaForTesting();	2211
2288	}	2212	if (auto* storageManager = session->storageManager())
2289	completionHandler();	2213	storageManager->resetQuotaForTesting(WTFMove(completionHandler));
2290	}	2214	}
2291		2215
2292	void NetworkProcess::clearStorage(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)	2216	void NetworkProcess::clearStorage(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
Lines 2298-2303 void NetworkProcess::clearStorage(PAL::SessionID sessionID, CompletionHandler<vo a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec12
2298	completionHandler();	2222	completionHandler();
2299	}	2223	}
2300		2224
		2225	void NetworkProcess::didIncreaseQuota(PAL::SessionID sessionID, const ClientOrigin& origin, QuotaIncreaseRequestIdentifier identifier, std::optional<uint64_t> newQuota)
		2226	{
		2227	auto* session = networkSession(sessionID);
		2228	if (!session)
		2229	return;
		2230
		2231	if (auto* manager = session->storageManager())
		2232	manager->didIncreaseQuota(origin, identifier, newQuota);
		2233	}
		2234
2301	void NetworkProcess::renameOriginInWebsiteData(PAL::SessionID sessionID, const URL& oldName, const URL& newName, OptionSet<WebsiteDataType> dataTypes, CompletionHandler<void()>&& completionHandler)	2235	void NetworkProcess::renameOriginInWebsiteData(PAL::SessionID sessionID, const URL& oldName, const URL& newName, OptionSet<WebsiteDataType> dataTypes, CompletionHandler<void()>&& completionHandler)
2302	{	2236	{
2303	auto aggregator = CallbackAggregator::create(WTFMove(completionHandler));	2237	auto aggregator = CallbackAggregator::create(WTFMove(completionHandler));
Lines 2310-2318 void NetworkProcess::renameOriginInWebsiteData(PAL::SessionID sessionID, const U a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec13
2310	auto* session = networkSession(sessionID);	2244	auto* session = networkSession(sessionID);
2311	if (auto* manager = session ? session->storageManager() : nullptr)	2245	if (auto* manager = session ? session->storageManager() : nullptr)
2312	manager->moveData(oldOrigin, newOrigin, [aggregator] { });	2246	manager->moveData(oldOrigin, newOrigin, [aggregator] { });
2313
2314	if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath())
2315	session->ensureWebIDBServer().renameOrigin(oldOrigin, newOrigin, [aggregator] { });
2316	}	2247	}
2317		2248
2318	#if ENABLE(SERVICE_WORKER)	2249	#if ENABLE(SERVICE_WORKER)
Lines 2372-2378 RefPtr<StorageQuotaManager> NetworkProcess::storageQuotaManager(PAL::SessionID s a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec14
2372	StorageQuotaManager::UsageGetter usageGetter = [cacheRootPath = sessionStorageQuotaManager->cacheRootPath().isolatedCopy(), idbRootPath = idbRootPath.isolatedCopy(), origin = origin.isolatedCopy()]() {	2303	StorageQuotaManager::UsageGetter usageGetter = [cacheRootPath = sessionStorageQuotaManager->cacheRootPath().isolatedCopy(), idbRootPath = idbRootPath.isolatedCopy(), origin = origin.isolatedCopy()]() {
2373	ASSERT(!isMainRunLoop());	2304	ASSERT(!isMainRunLoop());
2374		2305
2375	return CacheStorage::Engine::diskUsage(cacheRootPath, origin) + IDBServer::IDBServer::diskUsage(idbRootPath, origin);	2306	auto cacheStoragePath = CacheStorage::Engine::storagePath(cacheRootPath, origin);
		2307	return CacheStorage::Engine::diskUsage(cacheStoragePath) + IDBServer::IDBServer::diskUsage(idbRootPath, origin);
2376	};	2308	};
2377	StorageQuotaManager::QuotaIncreaseRequester quotaIncreaseRequester = [this, weakThis = WeakPtr { *this }, sessionID, origin] (uint64_t currentQuota, uint64_t currentSpace, uint64_t requestedIncrease, auto&& callback) {	2309	StorageQuotaManager::QuotaIncreaseRequester quotaIncreaseRequester = [this, weakThis = WeakPtr { *this }, sessionID, origin] (uint64_t currentQuota, uint64_t currentSpace, uint64_t requestedIncrease, auto&& callback) {
2378	ASSERT(isMainRunLoop());	2310	ASSERT(isMainRunLoop());
Lines 2586-2593 void NetworkProcess::removeKeptAliveLoad(NetworkResourceLoader& loader) a/Source/WebKit/NetworkProcess/NetworkProcess.cpp_sec15
2586	void NetworkProcess::connectionToWebProcessClosed(IPC::Connection& connection, PAL::SessionID sessionID)	2518	void NetworkProcess::connectionToWebProcessClosed(IPC::Connection& connection, PAL::SessionID sessionID)
2587	{	2519	{
2588	if (auto* session = networkSession(sessionID)) {	2520	if (auto* session = networkSession(sessionID)) {
2589	if (auto* server = session->webIDBServer())
2590	server->removeConnection(connection);
2591	if (auto* manager = session->storageManager())	2521	if (auto* manager = session->storageManager())
2592	manager->stopReceivingMessageFromConnection(connection);	2522	manager->stopReceivingMessageFromConnection(connection);
2593	}	2523	}

Lines 33-38 a/Source/WebKit/NetworkProcess/NetworkProcess.h_sec1
- a/Source/WebKit/NetworkProcess/NetworkProcess.h -9 / +5 lines
33	#include "LocalStorageDatabaseTracker.h"	33	#include "LocalStorageDatabaseTracker.h"
34	#include "NetworkContentRuleListManager.h"	34	#include "NetworkContentRuleListManager.h"
35	#include "NetworkResourceLoadIdentifier.h"	35	#include "NetworkResourceLoadIdentifier.h"
		36	#include "QuotaIncreaseRequestIdentifier.h"
36	#include "RTCDataChannelRemoteManagerProxy.h"	37	#include "RTCDataChannelRemoteManagerProxy.h"
37	#include "SandboxExtension.h"	38	#include "SandboxExtension.h"
38	#include "WebPageProxyIdentifier.h"	39	#include "WebPageProxyIdentifier.h"
Lines 288-299 public: a/Source/WebKit/NetworkProcess/NetworkProcess.h_sec2
288	NetworkContentRuleListManager& networkContentRuleListManager() { return m_networkContentRuleListManager; }	289	NetworkContentRuleListManager& networkContentRuleListManager() { return m_networkContentRuleListManager; }
289	#endif	290	#endif
290		291
291	bool shouldSuspendIDBServers() const { return m_shouldSuspendIDBServers; }
292
293	void syncLocalStorage(CompletionHandler<void()>&&);	292	void syncLocalStorage(CompletionHandler<void()>&&);
294		293
295	void resetQuota(PAL::SessionID, CompletionHandler<void()>&&);	294	void resetQuota(PAL::SessionID, CompletionHandler<void()>&&);
296	void clearStorage(PAL::SessionID, CompletionHandler<void()>&&);	295	void clearStorage(PAL::SessionID, CompletionHandler<void()>&&);
		296	void didIncreaseQuota(PAL::SessionID, const WebCore::ClientOrigin&, QuotaIncreaseRequestIdentifier, std::optional<uint64_t> newQuota);
297	void renameOriginInWebsiteData(PAL::SessionID, const URL&, const URL&, OptionSet<WebsiteDataType>, CompletionHandler<void()>&&);	297	void renameOriginInWebsiteData(PAL::SessionID, const URL&, const URL&, OptionSet<WebsiteDataType>, CompletionHandler<void()>&&);
298		298
299	#if PLATFORM(IOS_FAMILY)	299	#if PLATFORM(IOS_FAMILY)
Lines 473-480 private: a/Source/WebKit/NetworkProcess/NetworkProcess.h_sec3
473	void registerURLSchemeAsNoAccess(const String&) const;	473	void registerURLSchemeAsNoAccess(const String&) const;
474	void registerURLSchemeAsCORSEnabled(const String&) const;	474	void registerURLSchemeAsCORSEnabled(const String&) const;
475		475
476	void suspendIDBServers(bool isSuspensionImminent);
477
478	#if PLATFORM(IOS_FAMILY)	476	#if PLATFORM(IOS_FAMILY)
479	void setIsHoldingLockedFiles(bool);	477	void setIsHoldingLockedFiles(bool);
480	#endif	478	#endif
Lines 482-487 private: a/Source/WebKit/NetworkProcess/NetworkProcess.h_sec4
482	class SessionStorageQuotaManager {	480	class SessionStorageQuotaManager {
483	WTF_MAKE_FAST_ALLOCATED;	481	WTF_MAKE_FAST_ALLOCATED;
484	public:	482	public:
		483	SessionStorageQuotaManager() = delete;
485	SessionStorageQuotaManager(const String& cacheRootPath, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota)	484	SessionStorageQuotaManager(const String& cacheRootPath, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota)
486	: m_cacheRootPath(cacheRootPath)	485	: m_cacheRootPath(cacheRootPath)
487	, m_defaultQuota(defaultQuota)	486	, m_defaultQuota(defaultQuota)
Lines 508-515 private: a/Source/WebKit/NetworkProcess/NetworkProcess.h_sec5
508	private:	507	private:
509	String m_cacheRootPath;	508	String m_cacheRootPath;
510	String m_idbRootPath;	509	String m_idbRootPath;
511	uint64_t m_defaultQuota { WebCore::StorageQuotaManager::defaultQuota() };	510	uint64_t m_defaultQuota;
512	uint64_t m_defaultThirdPartyQuota { WebCore::StorageQuotaManager::defaultThirdPartyQuota() };	511	uint64_t m_defaultThirdPartyQuota;
513	HashMap<WebCore::ClientOrigin, RefPtr<WebCore::StorageQuotaManager>> m_storageQuotaManagers;	512	HashMap<WebCore::ClientOrigin, RefPtr<WebCore::StorageQuotaManager>> m_storageQuotaManagers;
514	};	513	};
515	void addSessionStorageQuotaManager(PAL::SessionID, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota, const String& cacheRootPath, SandboxExtension::Handle&);	514	void addSessionStorageQuotaManager(PAL::SessionID, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota, const String& cacheRootPath, SandboxExtension::Handle&);
Lines 549-557 private: a/Source/WebKit/NetworkProcess/NetworkProcess.h_sec6
549	WebSQLiteDatabaseTracker m_webSQLiteDatabaseTracker;	548	WebSQLiteDatabaseTracker m_webSQLiteDatabaseTracker;
550	RefPtr<ProcessAssertion> m_holdingLockedFileAssertion;	549	RefPtr<ProcessAssertion> m_holdingLockedFileAssertion;
551	#endif	550	#endif
552
553	bool m_shouldSuspendIDBServers { false };
554	uint64_t m_suspensionIdentifier { 0 };
555		551
556	#if ENABLE(WEB_RTC)	552	#if ENABLE(WEB_RTC)
557	RefPtr<RTCDataChannelRemoteManagerProxy> m_rtcDataChannelProxy;	553	RefPtr<RTCDataChannelRemoteManagerProxy> m_rtcDataChannelProxy;

Lines 204-211 void NetworkSession::invalidateAndCancel() a/Source/WebKit/NetworkProcess/NetworkSession.cpp_sec1
- a/Source/WebKit/NetworkProcess/NetworkSession.cpp -45 / +6 lines
204	if (m_resourceLoadStatistics)	204	if (m_resourceLoadStatistics)
205	m_resourceLoadStatistics->invalidateAndCancel();	205	m_resourceLoadStatistics->invalidateAndCancel();
206	#endif	206	#endif
207	if (auto server = std::exchange(m_webIDBServer, nullptr))
208	server->close();
209	if (auto manager = std::exchange(m_storageManager, nullptr))	207	if (auto manager = std::exchange(m_storageManager, nullptr))
210	manager->close();	208	manager->close();
211	m_cacheEngine = nullptr;	209	m_cacheEngine = nullptr;
Lines 653-707 bool NetworkSession::hasServiceWorkerDatabasePath() const a/Source/WebKit/NetworkProcess/NetworkSession.cpp_sec2
653		651
654	#endif // ENABLE(SERVICE_WORKER)	652	#endif // ENABLE(SERVICE_WORKER)
655		653
656	WebIDBServer& NetworkSession::ensureWebIDBServer()	654	void NetworkSession::addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle, const String& idbStoragePath, SandboxExtension::Handle& idbStoragePathHandle, const String& cacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyQuota)
657	{
658	if (!m_webIDBServer) {
659	String path;
660	if (!sessionID().isEphemeral()) {
661	ASSERT(!m_idbDatabasePath.isNull());
662	path = m_idbDatabasePath;
663	}
664
665	auto spaceRequester = [networkProcess = Ref { networkProcess() }, sessionID = sessionID()](const auto& origin, uint64_t spaceRequested) {
666	return networkProcess->storageQuotaManager(sessionID, origin)->requestSpaceOnBackgroundThread(spaceRequested);
667	};
668
669	m_webIDBServer = WebIDBServer::create(sessionID(), path, WTFMove(spaceRequester));
670	if (networkProcess().shouldSuspendIDBServers())
671	m_webIDBServer->suspend(WebIDBServer::SuspensionCondition::Always);
672	}
673	return *m_webIDBServer;
674	}
675
676	void NetworkSession::closeIDBServer(CompletionHandler<void()>&& completionHandler)
677	{
678	if (!m_webIDBServer)
679	return completionHandler();
680
681	std::exchange(m_webIDBServer, nullptr)->close(WTFMove(completionHandler));
682	}
683
684	void NetworkSession::addIndexedDatabaseSession(const String& indexedDatabaseDirectory, SandboxExtension::Handle& handle)
685	{
686	// *********
687	// IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
688	// *********
689	auto isNew = m_idbDatabasePath.isNull();
690	m_idbDatabasePath = indexedDatabaseDirectory;
691	if (isNew) {
692	SandboxExtension::consumePermanently(handle);
693	networkProcess().setSessionStorageQuotaManagerIDBRootPath(sessionID(), indexedDatabaseDirectory);
694	}
695	}
696
697	void NetworkSession::addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle)
698	{	655	{
699	if (m_storageManager)	656	if (m_storageManager)
700	return;	657	return;
701		658
702	SandboxExtension::consumePermanently(generalStoragePathHandle);	659	SandboxExtension::consumePermanently(generalStoragePathHandle);
703	SandboxExtension::consumePermanently(localStoragePathHandle);	660	SandboxExtension::consumePermanently(localStoragePathHandle);
704	m_storageManager = NetworkStorageManager::create(sessionID(), generalStoragePath, localStoragePath);	661	SandboxExtension::consumePermanently(idbStoragePathHandle);
		662	IPC::Connection::UniqueID connectionID;
		663	if (auto* connection = networkProcess().parentProcessConnection())
		664	connectionID = connection->uniqueID();
		665	m_storageManager = NetworkStorageManager::create(sessionID(), connectionID, generalStoragePath, localStoragePath, idbStoragePath, cacheStoragePath, defaultOriginQuota, defaultThirdPartyQuota);
705	}	666	}
706		667
707	void NetworkSession::ensureCacheEngine(Function<void(CacheStorage::Engine&)>&& callback)	668	void NetworkSession::ensureCacheEngine(Function<void(CacheStorage::Engine&)>&& callback)

Lines 210-223 public: a/Source/WebKit/NetworkProcess/NetworkSession.h_sec1
- a/Source/WebKit/NetworkProcess/NetworkSession.h -10 / +1 lines
210	void addServiceWorkerSession(bool processTerminationDelayEnabled, String&& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle&);	210	void addServiceWorkerSession(bool processTerminationDelayEnabled, String&& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle&);
211	#endif	211	#endif
212		212
213	WebIDBServer* webIDBServer() { return m_webIDBServer.get(); }
214	WebIDBServer& ensureWebIDBServer();
215	void closeIDBServer(CompletionHandler<void()>&&);
216	void addIndexedDatabaseSession(const String& indexedDatabaseDirectory, SandboxExtension::Handle&);
217	bool hasIDBDatabasePath() const { return !m_idbDatabasePath.isEmpty(); }
218
219	NetworkStorageManager* storageManager() { return m_storageManager.get(); }	213	NetworkStorageManager* storageManager() { return m_storageManager.get(); }
220	void addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle);	214	void addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle, const String& idbStoragePath, SandboxExtension::Handle& idbStoragePathHandle, const String& cacheStoragePath, uint64_t defaultOriginQuota, uint64_t defaultThirdPartyQuota);
221		215
222	CacheStorage::Engine* cacheEngine() { return m_cacheEngine.get(); }	216	CacheStorage::Engine* cacheEngine() { return m_cacheEngine.get(); }
223	void ensureCacheEngine(Function<void(CacheStorage::Engine&)>&&);	217	void ensureCacheEngine(Function<void(CacheStorage::Engine&)>&&);
Lines 319-327 protected: a/Source/WebKit/NetworkProcess/NetworkSession.h_sec2
319	std::unique_ptr<WebCore::SWServer> m_swServer;	313	std::unique_ptr<WebCore::SWServer> m_swServer;
320	#endif	314	#endif
321		315
322	String m_idbDatabasePath;
323	RefPtr<WebIDBServer> m_webIDBServer;
324
325	RefPtr<NetworkStorageManager> m_storageManager;	316	RefPtr<NetworkStorageManager> m_storageManager;
326	RefPtr<CacheStorage::Engine> m_cacheEngine;	317	RefPtr<CacheStorage::Engine> m_cacheEngine;
327	Vector<Function<void(CacheStorage::Engine&)>> m_cacheStorageParametersCallbacks;	318	Vector<Function<void(CacheStorage::Engine&)>> m_cacheStorageParametersCallbacks;

Lines 31-36 a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp_sec1
- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp -15 / +25 lines
31	#include "NetworkCacheIOChannel.h"	31	#include "NetworkCacheIOChannel.h"
32	#include "NetworkProcess.h"	32	#include "NetworkProcess.h"
33	#include "NetworkSession.h"	33	#include "NetworkSession.h"
		34	#include "NetworkStorageManager.h"
34	#include "WebsiteDataType.h"	35	#include "WebsiteDataType.h"
35	#include <WebCore/CacheQueryOptions.h>	36	#include <WebCore/CacheQueryOptions.h>
36	#include <WebCore/RetrieveRecordsOptions.h>	37	#include <WebCore/RetrieveRecordsOptions.h>
Lines 203-242 static uint64_t getDirectorySize(const String& directoryPath) a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp_sec2
203	return directorySize;	204	return directorySize;
204	}	205	}
205		206
206	uint64_t Engine::diskUsage(const String& rootPath, const WebCore::ClientOrigin& origin)	207	String Engine::storagePath(const String& rootDirectory, const WebCore::ClientOrigin& origin)
207	{	208	{
208	ASSERT(!isMainRunLoop());	209	ASSERT(!isMainRunLoop());
		210
		211	if (rootDirectory.isEmpty())
		212	return emptyString();
209		213
210	if (rootPath.isEmpty())	214	String saltPath = FileSystem::pathByAppendingComponent(rootDirectory, "salt"_s);
211	return 0;
212
213	String saltPath = FileSystem::pathByAppendingComponent(rootPath, "salt"_s);
214	auto salt = FileSystem::readOrMakeSalt(saltPath);	215	auto salt = FileSystem::readOrMakeSalt(saltPath);
215	if (!salt)	216	if (!salt)
216	return 0;	217	return emptyString();
217		218
218	Key key(origin.topOrigin.toString(), origin.clientOrigin.toString(), { }, { }, *salt);	219	Key key(origin.topOrigin.toString(), origin.clientOrigin.toString(), { }, { }, *salt);
219	String directoryPath = FileSystem::pathByAppendingComponent(rootPath, key.hashAsString());	220	return FileSystem::pathByAppendingComponent(rootDirectory, key.hashAsString());
		221	}
		222
		223	uint64_t Engine::diskUsage(const String& originDirectory)
		224	{
		225	ASSERT(!isMainRunLoop());
		226
		227	if (originDirectory.isEmpty())
		228	return 0;
220		229
221	String sizeFilePath = Caches::cachesSizeFilename(directoryPath);	230	String sizeFilePath = Caches::cachesSizeFilename(originDirectory);
222	if (auto recordedSize = readSizeFile(sizeFilePath))	231	if (auto recordedSize = readSizeFile(sizeFilePath))
223	return *recordedSize;	232	return *recordedSize;
224		233
225	return getDirectorySize(directoryPath);	234	return getDirectorySize(originDirectory);
226	}	235	}
227		236
228	void Engine::requestSpace(const WebCore::ClientOrigin& origin, uint64_t spaceRequested, CompletionHandler<void(WebCore::StorageQuotaManager::Decision)>&& callback)	237	void Engine::requestSpace(const WebCore::ClientOrigin& origin, uint64_t spaceRequested, CompletionHandler<void(bool)>&& callback)
229	{	238	{
230	ASSERT(isMainThread());	239	ASSERT(isMainThread());
231		240
232	if (!m_networkProcess)	241	if (!m_networkProcess)
233	callback(WebCore::StorageQuotaManager::Decision::Deny);	242	callback(false);
234		243
235	RefPtr<WebCore::StorageQuotaManager> storageQuotaManager = m_networkProcess->storageQuotaManager(m_sessionID, origin);	244	auto* session = m_networkProcess->networkSession(m_sessionID);
236	if (!storageQuotaManager)	245	if (!session)
237	callback(WebCore::StorageQuotaManager::Decision::Deny);	246	callback(false);
238		247
239	storageQuotaManager->requestSpaceOnMainThread(spaceRequested, WTFMove(callback));	248	if (auto* storageManager = session->storageManager())
		249	storageManager->requestSpace(origin, spaceRequested, WTFMove(callback));
240	}	250	}
241		251
242	Engine::Engine(NetworkSession& networkSession, String&& rootPath)	252	Engine::Engine(NetworkSession& networkSession, String&& rootPath)

Lines 29-35 a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h_sec1
- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h -3 / +3 lines
29	#include "NetworkCacheData.h"	29	#include "NetworkCacheData.h"
30	#include "WebsiteData.h"	30	#include "WebsiteData.h"
31	#include <WebCore/ClientOrigin.h>	31	#include <WebCore/ClientOrigin.h>
32	#include <WebCore/StorageQuotaManager.h>
33	#include <pal/SessionID.h>	32	#include <pal/SessionID.h>
34	#include <wtf/HashMap.h>	33	#include <wtf/HashMap.h>
35	#include <wtf/RefCounted.h>	34	#include <wtf/RefCounted.h>
Lines 84-91 public: a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h_sec2
84		83
85	static void initializeQuotaUser(NetworkSession&, const WebCore::ClientOrigin&, CompletionHandler<void()>&&);	84	static void initializeQuotaUser(NetworkSession&, const WebCore::ClientOrigin&, CompletionHandler<void()>&&);
86		85
87	static uint64_t diskUsage(const String& rootPath, const WebCore::ClientOrigin&);	86	static String storagePath(const String& rootDirectory, const WebCore::ClientOrigin&);
88	void requestSpace(const WebCore::ClientOrigin&, uint64_t spaceRequested, CompletionHandler<void(WebCore::StorageQuotaManager::Decision)>&&);	87	static uint64_t diskUsage(const String& originDirectory);
		88	void requestSpace(const WebCore::ClientOrigin&, uint64_t spaceRequested, CompletionHandler<void(bool)>&&);
89		89
90	bool shouldPersist() const { return !!m_ioQueue;}	90	bool shouldPersist() const { return !!m_ioQueue;}
91		91

Lines 109-127 void NetworkProcess::setIsHoldingLockedFiles(bool isHoldingLockedFiles) a/Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm_sec1
- a/Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm -13 lines
109	// We synchronously take a process assertion when beginning a SQLite transaction so that we don't get suspended	109	// We synchronously take a process assertion when beginning a SQLite transaction so that we don't get suspended
110	// while holding a locked file. We would get killed if suspended while holding locked files.	110	// while holding a locked file. We would get killed if suspended while holding locked files.
111	m_holdingLockedFileAssertion = ProcessAssertion::create(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskInterruptable, ProcessAssertion::Mode::Sync);	111	m_holdingLockedFileAssertion = ProcessAssertion::create(getCurrentProcessID(), "Network Process is holding locked files"_s, ProcessAssertionType::FinishTaskInterruptable, ProcessAssertion::Mode::Sync);
112	m_holdingLockedFileAssertion->setPrepareForInvalidationHandler([this, weakThis = WeakPtr { *this }]() mutable {
113	ASSERT(isMainRunLoop());
114	if (!weakThis)
115	return;
116
117	if (!m_shouldSuspendIDBServers)
118	return;
119
120	forEachNetworkSession([](auto& session) {
121	if (auto* server = session.webIDBServer())
122	server->suspend();
123	});
124	});
125	}	112	}
126		113
127	} // namespace WebKit	114	} // namespace WebKit

Line 0 a/Source/WebKit/NetworkProcess/storage/IDBStorageConnectionToClient.cpp_sec1
- a/Source/WebKit/NetworkProcess/storage/IDBStorageConnectionToClient.cpp +191 lines
		1	/*
		2	* Copyright (C) 2016-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	#include "config.h"
		27	#include "IDBStorageConnectionToClient.h"
		28
		29	#include "WebCoreArgumentCoders.h"
		30	#include "WebIDBConnectionToServerMessages.h"
		31	#include "WebIDBResult.h"
		32	#include <WebCore/IDBRequestData.h>
		33	#include <WebCore/IDBResultData.h>
		34	#include <WebCore/UniqueIDBDatabaseConnection.h>
		35
		36	namespace WebKit {
		37
		38	IDBStorageConnectionToClient::IDBStorageConnectionToClient(IPC::Connection::UniqueID connection, WebCore::IDBConnectionIdentifier identifier)
		39	: m_connection(connection)
		40	, m_identifier(identifier)
		41	, m_connectionToClient(WebCore::IDBServer::IDBConnectionToClient::create(*this))
		42	{
		43	}
		44
		45	IDBStorageConnectionToClient::~IDBStorageConnectionToClient()
		46	{
		47	m_connectionToClient->clearDelegate();
		48	}
		49
		50	WebCore::IDBServer::IDBConnectionToClient& IDBStorageConnectionToClient::connectionToClient()
		51	{
		52	return m_connectionToClient;
		53	}
		54
		55	template<class MessageType> void IDBStorageConnectionToClient::didGetResult(const WebCore::IDBResultData& resultData)
		56	{
		57	if (resultData.type() == WebCore::IDBResultType::Error) {
		58	IPC::Connection::send(m_connection, MessageType(resultData), 0);
		59	return;
		60	}
		61
		62	if (resultData.type() == WebCore::IDBResultType::GetAllRecordsSuccess && resultData.getAllResult().type() == WebCore::IndexedDB::GetAllType::Keys) {
		63	IPC::Connection::send(m_connection, MessageType(resultData), 0);
		64	return;
65	}
66
67	auto blobFilePaths = resultData.type() == WebCore::IDBResultType::GetAllRecordsSuccess ? resultData.getAllResult().allBlobFilePaths() : resultData.getResult().value().blobFilePaths();
68	if (blobFilePaths.isEmpty()) {
69	IPC::Connection::send(m_connection, MessageType(resultData), 0);
70	return;
71	}
72
73	IPC::Connection::send(m_connection, MessageType(resultData), 0);
74	}
75
76	void IDBStorageConnectionToClient::didDeleteDatabase(const WebCore::IDBResultData& resultData)
77	{
78	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteDatabase(resultData), 0);
79	}
80
81	void IDBStorageConnectionToClient::didOpenDatabase(const WebCore::IDBResultData& resultData)
82	{
83	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidOpenDatabase(resultData), 0);
84	}
85
86	void IDBStorageConnectionToClient::didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
87	{
88	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidStartTransaction(transactionIdentifier, error), 0);
89	}
90
91	void IDBStorageConnectionToClient::didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
92	{
93	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidAbortTransaction(transactionIdentifier, error), 0);
94	}
95
96	void IDBStorageConnectionToClient::didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
97	{
98	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCommitTransaction(transactionIdentifier, error), 0);
99	}
100
101	void IDBStorageConnectionToClient::didCreateObjectStore(const WebCore::IDBResultData& resultData)
102	{
103	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCreateObjectStore(resultData), 0);
104	}
105
106	void IDBStorageConnectionToClient::didDeleteObjectStore(const WebCore::IDBResultData& resultData)
107	{
108	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteObjectStore(resultData), 0);
109	}
110
111	void IDBStorageConnectionToClient::didRenameObjectStore(const WebCore::IDBResultData& resultData)
112	{
113	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidRenameObjectStore(resultData), 0);
114	}
115
116	void IDBStorageConnectionToClient::didClearObjectStore(const WebCore::IDBResultData& resultData)
117	{
118	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidClearObjectStore(resultData), 0);
119	}
120
121	void IDBStorageConnectionToClient::didCreateIndex(const WebCore::IDBResultData& resultData)
122	{
123	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCreateIndex(resultData), 0);
124	}
125
126	void IDBStorageConnectionToClient::didDeleteIndex(const WebCore::IDBResultData& resultData)
127	{
128	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteIndex(resultData), 0);
129	}
130
131	void IDBStorageConnectionToClient::didRenameIndex(const WebCore::IDBResultData& resultData)
132	{
133	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidRenameIndex(resultData), 0);
134	}
135
136	void IDBStorageConnectionToClient::didPutOrAdd(const WebCore::IDBResultData& resultData)
137	{
138	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidPutOrAdd(resultData), 0);
139	}
140
141	void IDBStorageConnectionToClient::didGetRecord(const WebCore::IDBResultData& resultData)
142	{
143	didGetResult<Messages::WebIDBConnectionToServer::DidGetRecord>(resultData);
144	}
145
146	void IDBStorageConnectionToClient::didGetAllRecords(const WebCore::IDBResultData& resultData)
147	{
148	didGetResult<Messages::WebIDBConnectionToServer::DidGetAllRecords>(resultData);
149	}
150
151	void IDBStorageConnectionToClient::didGetCount(const WebCore::IDBResultData& resultData)
152	{
153	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidGetCount(resultData), 0);
154	}
155
156	void IDBStorageConnectionToClient::didDeleteRecord(const WebCore::IDBResultData& resultData)
157	{
158	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidDeleteRecord(resultData), 0);
159	}
160
161	void IDBStorageConnectionToClient::didOpenCursor(const WebCore::IDBResultData& resultData)
162	{
163	didGetResult<Messages::WebIDBConnectionToServer::DidOpenCursor>(resultData);
164	}
165
166	void IDBStorageConnectionToClient::didIterateCursor(const WebCore::IDBResultData& resultData)
167	{
168	didGetResult<Messages::WebIDBConnectionToServer::DidIterateCursor>(resultData);
169	}
170
171	void IDBStorageConnectionToClient::didGetAllDatabaseNamesAndVersions(const WebCore::IDBResourceIdentifier& requestIdentifier, const Vector<WebCore::IDBDatabaseNameAndVersion>& databases)
172	{
173	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidGetAllDatabaseNamesAndVersions(requestIdentifier, databases), 0);
174	}
175
176	void IDBStorageConnectionToClient::fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
177	{
178	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::FireVersionChangeEvent(connection.identifier(), requestIdentifier, requestedVersion), 0);
179	}
180
181	void IDBStorageConnectionToClient::didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBError& error)
182	{
183	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::DidCloseFromServer(connection.identifier(), error), 0);
184	}
185
186	void IDBStorageConnectionToClient::notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
187	{
188	IPC::Connection::send(m_connection, Messages::WebIDBConnectionToServer::NotifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion), 0);
189	}
190
191	} // namespace WebKit

Line 0 a/Source/WebKit/NetworkProcess/storage/IDBStorageRegistry.h_sec1
- a/Source/WebKit/NetworkProcess/storage/IDBStorageRegistry.h +62 lines
	1	/*
	2	* Copyright (C) 2021 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 "Connection.h"
	29	#include <WebCore/IDBResourceIdentifier.h>
	30	#include <wtf/WeakPtr.h>
	31
	32	namespace WebCore {
	33	namespace IDBServer {
	34	class UniqueIDBDatabaseConnection;
	35	class UniqueIDBDatabaseTransaction;
	36	}
	37	}
	38
	39	namespace WebKit {
	40
	41	class IDBStorageConnectionToClient;
	42
	43	class IDBStorageRegistry {
	44	WTF_MAKE_FAST_ALLOCATED;
	45	public:
	46	IDBStorageRegistry();
	47	WebCore::IDBServer::IDBConnectionToClient& getOrCreateConnectionToClient(IPC::Connection::UniqueID, WebCore::IDBConnectionIdentifier);
	48	void removeConnectionToClient(IPC::Connection::UniqueID);
	49	void registerConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection&);
	50	void unregisterConnection(WebCore::IDBServer::UniqueIDBDatabaseConnection&);
	51	WebCore::IDBServer::UniqueIDBDatabaseConnection* getConnection(uint64_t identifier);
	52	void registerTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&);
	53	void unregisterTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&);
	54	WebCore::IDBServer::UniqueIDBDatabaseTransaction* getTransaction(WebCore::IDBResourceIdentifier);
	55
	56	private:
	57	HashMap<WebCore::IDBConnectionIdentifier, std::unique_ptr<IDBStorageConnectionToClient>> m_connectionsToClient;
	58	HashMap<uint64_t, WeakPtr<WebCore::IDBServer::UniqueIDBDatabaseConnection>> m_connections;
	59	HashMap<WebCore::IDBResourceIdentifier, WeakPtr<WebCore::IDBServer::UniqueIDBDatabaseTransaction>> m_transactions;
	60	};
	61
	62	} // namespace WebKit

Lines 47-50 a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.messages.in_sec1
- a/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.messages.in +27 lines
47	SetItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String key, String value, String urlString) -> (bool quotaException) Async WantsConnection	47	SetItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String key, String value, String urlString) -> (bool quotaException) Async WantsConnection
48	RemoveItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String key, String urlString) -> () Async WantsConnection	48	RemoveItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String key, String urlString) -> () Async WantsConnection
49	Clear(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String urlString) -> () Async WantsConnection	49	Clear(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String urlString) -> () Async WantsConnection
		50
		51	OpenDatabase(WebCore::IDBRequestData requestData) WantsConnection
		52	OpenDBRequestCancelled(WebCore::IDBRequestData requestData)
		53	DeleteDatabase(WebCore::IDBRequestData requestData) WantsConnection
		54	EstablishTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBTransactionInfo info)
		55	DatabaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
		56	DatabaseConnectionClosed(uint64_t databaseConnectionIdentifier)
		57	AbortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier)
		58	DidFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier requestIdentifier, WebCore::IndexedDB::ConnectionClosedOnBehalfOfServer connectionClosedOnBehalfOfServer)
		59	DidFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier)
		60	AbortTransaction(WebCore::IDBResourceIdentifier transactionIdentifier)
		61	CommitTransaction(WebCore::IDBResourceIdentifier transactionIdentifier, uint64_t pendingRequestCount)
		62	CreateObjectStore(WebCore::IDBRequestData requestData, WebCore::IDBObjectStoreInfo info)
		63	DeleteObjectStore(WebCore::IDBRequestData requestData, String objectStoreName)
		64	RenameObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String newName)
		65	ClearObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier)
		66	CreateIndex(WebCore::IDBRequestData requestData, WebCore::IDBIndexInfo info)
		67	DeleteIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String indexName)
		68	RenameIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, String newName)
		69	PutOrAdd(WebCore::IDBRequestData requestData, WebCore::IDBKeyData key, WebCore::IDBValue value, WebCore::IndexedDB::ObjectStoreOverwriteMode overwriteMode) WantsConnection
		70	GetRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBGetRecordData getRecordData)
		71	GetAllRecords(WebCore::IDBRequestData requestData, struct WebCore::IDBGetAllRecordsData getAllRecordsData)
		72	GetCount(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range)
		73	DeleteRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range)
		74	OpenCursor(WebCore::IDBRequestData requestData, WebCore::IDBCursorInfo info)
		75	IterateCursor(WebCore::IDBRequestData requestData, struct WebCore::IDBIterateCursorData data)
		76	GetAllDatabaseNamesAndVersions(WebCore::IDBResourceIdentifier requestIdentifier, struct WebCore::ClientOrigin origin) WantsConnection
50	}	77	}

Line 0 a/Source/WebKit/Shared/WebsiteData/QuotaIncreaseRequestIdentifier.h_sec1
- a/Source/WebKit/Shared/WebsiteData/QuotaIncreaseRequestIdentifier.h +35 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 QuotaIncreaseRequestIdentifierType { };
	33	using QuotaIncreaseRequestIdentifier = ObjectIdentifier<QuotaIncreaseRequestIdentifierType>;
	34
	35	} // namespace WebKit