⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 289474 in webkit


Ignore:
Timestamp:
Feb 9, 2022, 8:55:15 AM (5 years ago)
Author:
sihui_liu@apple.com
Message:

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

Reviewed by Chris Dumez.

Source/WebCore:

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::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:

Source/WebKit:

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. A new clas IDBStorageRegistry is added 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.

  1. 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.

  1. 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.

  1. 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::ensureConnectionToClient):
(WebKit::IDBStorageRegistry::removeConnectionToClient):
(WebKit::IDBStorageRegistry::registerConnection):
(WebKit::IDBStorageRegistry::unregisterConnection):
(WebKit::IDBStorageRegistry::registerTransaction):
(WebKit::IDBStorageRegistry::unregisterTransaction):
(WebKit::IDBStorageRegistry::connection):
(WebKit::IDBStorageRegistry::transaction):

  • 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):

Source/WebKitLegacy:

  • Storage/InProcessIDBServer.cpp:

(InProcessIDBServer::quotaManager):

Tools:

  • TestWebKitAPI/Tests/WebKitCocoa/IndexedDBFileName.mm:

(runTest):

  • TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm:
  • TestWebKitAPI/Tests/WebKitCocoa/IndexedDBSuspendImminently.mm:

(TEST):

  • TestWebKitAPI/Tests/WebKitCocoa/StoreBlobThenDelete.mm:

(TEST):

Location:
trunk
Files:
9 added
57 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r289471 r289474  
     12022-02-09  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 Chris Dumez.
     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::hasDataInMemory const):
     72        * Modules/indexeddb/server/UniqueIDBDatabase.h:
     73        (WebCore::IDBServer::UniqueIDBDatabase::server): Deleted.
     74        * Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp:
     75        (WebCore::IDBServer::UniqueIDBDatabaseConnection::UniqueIDBDatabaseConnection):
     76        (WebCore::IDBServer::UniqueIDBDatabaseConnection::~UniqueIDBDatabaseConnection):
     77        (WebCore::IDBServer::UniqueIDBDatabaseConnection::manager):
     78        * Modules/indexeddb/server/UniqueIDBDatabaseConnection.h:
     79        (WebCore::IDBServer::UniqueIDBDatabaseConnection::server): Deleted.
     80        * Modules/indexeddb/server/UniqueIDBDatabaseManager.h: Added.
     81        (WebCore::IDBServer::UniqueIDBDatabaseManager::~UniqueIDBDatabaseManager):
     82        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp:
     83        (WebCore::IDBServer::UniqueIDBDatabaseTransaction::UniqueIDBDatabaseTransaction):
     84        (WebCore::IDBServer::UniqueIDBDatabaseTransaction::~UniqueIDBDatabaseTransaction):
     85        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h:
     86        * Modules/indexeddb/shared/IDBError.h:
     87        (WebCore::IDBError::operator bool const):
     88        * Modules/indexeddb/shared/IDBRequestData.h:
     89        * Modules/indexeddb/shared/IDBResourceIdentifier.h:
     90        (WebCore::IDBResourceIdentifier::operator!= const):
     91        * WebCore.xcodeproj/project.pbxproj:
     92
    1932022-02-09  Alan Bujtas  <zalan@apple.com>
    294

  • trunk/Source/WebCore/Headers.cmake

    r289247 r289474  
    225225    Modules/indexeddb/server/IDBConnectionToClientDelegate.h
    226226    Modules/indexeddb/server/IDBServer.h
     227    Modules/indexeddb/server/IndexValueEntry.h
     228    Modules/indexeddb/server/IndexValueStore.h
     229    Modules/indexeddb/server/MemoryBackingStoreTransaction.h
    227230    Modules/indexeddb/server/MemoryIDBBackingStore.h
    228231    Modules/indexeddb/server/SQLiteIDBBackingStore.h
     232    Modules/indexeddb/server/SQLiteIDBTransaction.h
    229233    Modules/indexeddb/server/ServerOpenDBRequest.h
    230234    Modules/indexeddb/server/UniqueIDBDatabase.h
    231235    Modules/indexeddb/server/UniqueIDBDatabaseConnection.h
     236    Modules/indexeddb/server/UniqueIDBDatabaseManager.h
    232237    Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h
    233238

  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h

    r289247 r289474  
    7171
    7272    String databaseDirectoryRelativeToRoot(const String& rootDirectory, const String& versionString="v1") const;
    73     static String databaseDirectoryRelativeToRoot(const SecurityOriginData& topLevelOrigin, const SecurityOriginData& openingOrigin, const String& rootDirectory, const String& versionString);
     73    WEBCORE_EXPORT static String databaseDirectoryRelativeToRoot(const SecurityOriginData& topLevelOrigin, const SecurityOriginData& openingOrigin, const String& rootDirectory, const String& versionString);
    7474
    7575    template<class Encoder> void encode(Encoder&) const;

  • trunk/Source/WebCore/Modules/indexeddb/server/IDBConnectionToClient.h

    r275151 r289474  
    7575    void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
    7676
    77     void didGetAllDatabaseNamesAndVersions(const IDBResourceIdentifier&, Vector<IDBDatabaseNameAndVersion>&&);
     77    WEBCORE_EXPORT void didGetAllDatabaseNamesAndVersions(const IDBResourceIdentifier&, Vector<IDBDatabaseNameAndVersion>&&);
    7878
    7979    void registerDatabaseConnection(UniqueIDBDatabaseConnection&);
    8080    void unregisterDatabaseConnection(UniqueIDBDatabaseConnection&);
    81     void connectionToClientClosed();
     81    WEBCORE_EXPORT void connectionToClientClosed();
    8282    bool isClosed() { return m_isClosed; }
    8383    void clearDelegate() { m_delegate = nullptr; }

  • trunk/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp

    r288078 r289474  
    102102}
    103103
    104 void IDBServer::registerDatabaseConnection(UniqueIDBDatabaseConnection& connection)
     104void IDBServer::registerConnection(UniqueIDBDatabaseConnection& connection)
    105105{
    106106    ASSERT(!m_databaseConnections.contains(connection.identifier()));
    … …  
    108108}
    109109
    110 void IDBServer::unregisterDatabaseConnection(UniqueIDBDatabaseConnection& connection)
     110void IDBServer::unregisterConnection(UniqueIDBDatabaseConnection& connection)
    111111{
    112112    ASSERT(m_databaseConnections.contains(connection.identifier()));
    … …  
    129129    ASSERT(!isMainThread());
    130130    if (m_databaseDirectoryPath.isEmpty())
    131         return makeUnique<MemoryIDBBackingStore>(m_sessionID, identifier);
     131        return makeUnique<MemoryIDBBackingStore>(identifier);
    132132
    133133    ASSERT(!m_sessionID.isEphemeral());
    134134    if (identifier.isTransient())
    135         return makeUnique<MemoryIDBBackingStore>(m_sessionID, identifier);
    136 
    137     return makeUnique<SQLiteIDBBackingStore>(m_sessionID, identifier, m_databaseDirectoryPath);
     135        return makeUnique<MemoryIDBBackingStore>(identifier);
     136
     137    return makeUnique<SQLiteIDBBackingStore>(identifier, upgradedDatabaseDirectory(identifier));
    138138}
    139139
    … …  
    176176    if (database->tryClose())
    177177        m_uniqueIDBDatabaseMap.remove(database->identifier());
    178 }
    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;
    189178}
    190179
    … …  
    751740}
    752741
    753 StorageQuotaManager::Decision IDBServer::requestSpace(const ClientOrigin& origin, uint64_t taskSize) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
     742void IDBServer::requestSpace(const ClientOrigin& origin, uint64_t taskSize, CompletionHandler<void(bool)>&& completionHandler) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
    754743{
    755744    ASSERT(!isMainThread());
    … …  
    763752    m_lock.lock();
    764753
    765     return result;
     754    completionHandler(result == StorageQuotaManager::Decision::Grant);
    766755}
    767756
    … …  
    783772    if (!FileSystem::fileExists(newVersionDirectory))
    784773        FileSystem::makeAllDirectories(newVersionDirectory);
     774}
     775
     776String 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;
    785791}
    786792

  • trunk/Source/WebCore/Modules/indexeddb/server/IDBServer.h

    r280053 r289474  
    3131#include "UniqueIDBDatabase.h"
    3232#include "UniqueIDBDatabaseConnection.h"
     33#include "UniqueIDBDatabaseManager.h"
    3334#include <pal/HysteresisActivity.h>
    3435#include <pal/SessionID.h>
    … …  
    4950namespace IDBServer {
    5051
    51 class IDBServer {
    52     WTF_MAKE_FAST_ALLOCATED;
     52class IDBServer : public UniqueIDBDatabaseManager {
    5353public:
    5454    using StorageQuotaManagerSpaceRequester = Function<StorageQuotaManager::Decision(const ClientOrigin&, uint64_t spaceRequested)>;
    … …  
    8989    WEBCORE_EXPORT void getAllDatabaseNamesAndVersions(IDBConnectionIdentifier, const IDBResourceIdentifier&, const ClientOrigin&);
    9090
    91 
    92     void registerDatabaseConnection(UniqueIDBDatabaseConnection&);
    93     void unregisterDatabaseConnection(UniqueIDBDatabaseConnection&);
    94     void registerTransaction(UniqueIDBDatabaseTransaction&);
    95     void unregisterTransaction(UniqueIDBDatabaseTransaction&);
    96 
    97     std::unique_ptr<UniqueIDBDatabase> closeAndTakeUniqueIDBDatabase(UniqueIDBDatabase&);
    98 
    99     std::unique_ptr<IDBBackingStore> createBackingStore(const IDBDatabaseIdentifier&);
     91    // UniqueIDBDatabaseManager
     92    void registerConnection(UniqueIDBDatabaseConnection&) final;
     93    void unregisterConnection(UniqueIDBDatabaseConnection&) final;
     94    void registerTransaction(UniqueIDBDatabaseTransaction&) final;
     95    void unregisterTransaction(UniqueIDBDatabaseTransaction&) final;
     96    std::unique_ptr<IDBBackingStore> createBackingStore(const IDBDatabaseIdentifier&) final;
     97    void requestSpace(const ClientOrigin&, uint64_t size, CompletionHandler<void(bool)>&&) final;
    10098
    10199    WEBCORE_EXPORT HashSet<SecurityOriginData> getOrigins() const;
    … …  
    105103    WEBCORE_EXPORT void renameOrigin(const WebCore::SecurityOriginData&, const WebCore::SecurityOriginData&);
    106104
    107     StorageQuotaManager::Decision requestSpace(const ClientOrigin&, uint64_t taskSize);
    108105    WEBCORE_EXPORT static uint64_t diskUsage(const String& rootDirectory, const ClientOrigin&);
    109106
    … …  
    115112
    116113    void upgradeFilesIfNecessary();
     114    String upgradedDatabaseDirectory(const WebCore::IDBDatabaseIdentifier&);
    117115    void removeDatabasesModifiedSinceForVersion(WallTime, const String&);
    118116    void removeDatabasesWithOriginsForVersion(const Vector<SecurityOriginData>&, const String&);

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.cpp

    r279956 r289474  
    4545constexpr uint64_t maxGeneratedKeyValue = 0x20000000000000;
    4646
    47 MemoryIDBBackingStore::MemoryIDBBackingStore(PAL::SessionID sessionID, const IDBDatabaseIdentifier& identifier)
     47MemoryIDBBackingStore::MemoryIDBBackingStore(const IDBDatabaseIdentifier& identifier)
    4848    : m_identifier(identifier)
    49     , m_sessionID(sessionID)
    5049{
    5150}
    … …  
    135134
    136135    ASSERT(!m_objectStoresByIdentifier.contains(info.identifier()));
    137     auto objectStore = MemoryObjectStore::create(m_sessionID, info);
     136    auto objectStore = MemoryObjectStore::create(info);
    138137
    139138    m_databaseInfo->addExistingObjectStore(info);

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.h

    r280410 r289474  
    3131#include "IndexKey.h"
    3232#include "MemoryBackingStoreTransaction.h"
    33 #include <pal/SessionID.h>
    3433#include <wtf/HashMap.h>
    3534
    … …  
    4241    WTF_MAKE_FAST_ALLOCATED;
    4342public:
    44     MemoryIDBBackingStore(PAL::SessionID, const IDBDatabaseIdentifier&);
    45     ~MemoryIDBBackingStore();
     43    WEBCORE_EXPORT explicit MemoryIDBBackingStore(const IDBDatabaseIdentifier&);
     44    WEBCORE_EXPORT ~MemoryIDBBackingStore();
    4645
    4746    IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;
    … …  
    9392
    9493    IDBDatabaseIdentifier m_identifier;
    95     PAL::SessionID m_sessionID;
    9694    std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;
    9795

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryObjectStore.cpp

    r289128 r289474  
    3939#include <JavaScriptCore/JSCJSValueInlines.h>
    4040#include <JavaScriptCore/JSLock.h>
    41 #include <pal/SessionID.h>
    4241
    4342namespace WebCore {
    … …  
    4544namespace IDBServer {
    4645
    47 Ref<MemoryObjectStore> MemoryObjectStore::create(PAL::SessionID sessionID, const IDBObjectStoreInfo& info)
    48 {
    49     return adoptRef(*new MemoryObjectStore(sessionID, info));
    50 }
    51 
    52 MemoryObjectStore::MemoryObjectStore(PAL::SessionID, const IDBObjectStoreInfo& info)
     46Ref<MemoryObjectStore> MemoryObjectStore::create(const IDBObjectStoreInfo& info)
     47{
     48    return adoptRef(*new MemoryObjectStore(info));
     49}
     50
     51MemoryObjectStore::MemoryObjectStore(const IDBObjectStoreInfo& info)
    5352    : m_info(info)
    5453{

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryObjectStore.h

    r278393 r289474  
    3535#include <wtf/RefCounted.h>
    3636
    37 namespace PAL {
    38 class SessionID;
    39 }
    40 
    4137namespace WebCore {
    4238
    … …  
    6258class MemoryObjectStore : public RefCounted<MemoryObjectStore> {
    6359public:
    64     static Ref<MemoryObjectStore> create(PAL::SessionID, const IDBObjectStoreInfo&);
     60    static Ref<MemoryObjectStore> create(const IDBObjectStoreInfo&);
    6561
    6662    ~MemoryObjectStore();
    … …  
    109105
    110106private:
    111     MemoryObjectStore(PAL::SessionID, const IDBObjectStoreInfo&);
     107    MemoryObjectStore(const IDBObjectStoreInfo&);
    112108
    113109    IDBKeyDataSet::iterator lowestIteratorInRange(const IDBKeyRangeData&, bool reverse) const;

  • trunk/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp

    r289128 r289474  
    237237}
    238238
    239 SQLiteIDBBackingStore::SQLiteIDBBackingStore(PAL::SessionID sessionID, const IDBDatabaseIdentifier& identifier, const String& databaseRootDirectory)
    240     : m_sessionID(sessionID)
    241     , m_identifier(identifier)
    242     , m_databaseRootDirectory(databaseRootDirectory)
    243 {
    244     m_databaseDirectory = fullDatabaseDirectoryWithUpgrade();
     239SQLiteIDBBackingStore::SQLiteIDBBackingStore(const IDBDatabaseIdentifier& identifier, const String& databaseDirectory)
     240    : m_identifier(identifier)
     241    , m_databaseDirectory(databaseDirectory)
     242{
    245243}
    246244
    … …  
    913911}
    914912
    915 String SQLiteIDBBackingStore::filenameForDatabaseName() const
    916 {
    917     ASSERT(!m_identifier.databaseName().isNull());
    918 
    919     if (m_identifier.databaseName().isEmpty())
     913String SQLiteIDBBackingStore::encodeDatabaseName(const String& databaseName)
     914{
     915    ASSERT(!databaseName.isEmpty());
     916    if (databaseName.isEmpty())
    920917        return "%00";
    921918
    922     String filename = FileSystem::encodeForFileName(m_identifier.databaseName());
    923     filename.replace('.', "%2E");
     919    String filename = FileSystem::encodeForFileName(databaseName);
     920    filename.replaceWithLiteral('.', "%2E");
    924921
    925922    return filename;
     923}
     924
     925String SQLiteIDBBackingStore::decodeDatabaseName(const String& encodedName)
     926{
     927    if (encodedName == "%00"_s)
     928        return emptyString();
     929
     930    String name = encodedName;
     931    name.replace("%2E"_s, "."_s);
     932
     933    return FileSystem::decodeFromFilename(name);
    926934}
    927935
    … …  
    966974}
    967975
    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 
    985976IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info)
    986977{
    … …  
    992983    }
    993984
    994     String dbFilename = fullDatabasePath();
    995 
     985    String databasePath = fullDatabasePath();
     986    FileSystem::makeAllDirectories(FileSystem::parentPath(databasePath));
    996987    m_sqliteDB = makeUnique<SQLiteDatabase>();
    997     if (!m_sqliteDB->open(dbFilename)) {
    998         LOG_ERROR("Failed to open SQLite database at path '%s'", dbFilename.utf8().data());
     988    if (!m_sqliteDB->open(databasePath)) {
     989        LOG_ERROR("Failed to open SQLite database at path '%s'", databasePath.utf8().data());
    999990        closeSQLiteDB();
    1000991    }
    … …  
    10451036
    10461037    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());
    10481039        closeSQLiteDB();
    10491040        return IDBError { UnknownError, "Unable to establish IDB database file"_s };
    … …  
    27992790    SQLiteFileSystem::deleteDatabaseFile(databasePath);
    28002791    SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_databaseDirectory);
    2801     SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_identifier.databaseDirectoryRelativeToRoot(m_databaseRootDirectory));
    28022792}
    28032793

  • trunk/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h

    r280410 r289474  
    5252    WTF_MAKE_FAST_ALLOCATED;
    5353public:
    54     SQLiteIDBBackingStore(PAL::SessionID, const IDBDatabaseIdentifier&, const String& databaseRootDirectory);
    55    
    56     ~SQLiteIDBBackingStore() final;
     54    WEBCORE_EXPORT SQLiteIDBBackingStore(const IDBDatabaseIdentifier&, const String& databaseDirectory);
     55    WEBCORE_EXPORT ~SQLiteIDBBackingStore() final;
    5756
    5857    IDBError getOrEstablishDatabaseInfo(IDBDatabaseInfo&) final;
    … …  
    9594    IDBError getBlobRecordsForObjectStoreRecord(int64_t objectStoreRecord, Vector<String>& blobURLs, Vector<String>& blobFilePaths);
    9695
    97     static uint64_t databasesSizeForDirectory(const String& directory);
    98 
     96    WEBCORE_EXPORT static uint64_t databasesSizeForDirectory(const String& directory);
    9997    String databaseDirectory() const { return m_databaseDirectory; };
    100     static String fullDatabasePathForDirectory(const String&);
    101     static std::optional<IDBDatabaseNameAndVersion> databaseNameAndVersionFromFile(const String&);
    102 
    103     PAL::SessionID sessionID() const { return m_sessionID; }
     98    WEBCORE_EXPORT static String fullDatabasePathForDirectory(const String&);
     99    WEBCORE_EXPORT static String encodeDatabaseName(const String& databaseName);
     100    WEBCORE_EXPORT static String decodeDatabaseName(const String& encodedDatabaseName);
     101
     102    WEBCORE_EXPORT static std::optional<IDBDatabaseNameAndVersion> databaseNameAndVersionFromFile(const String&);
    104103
    105104private:
    106     String filenameForDatabaseName() const;
    107     String fullDatabaseDirectoryWithUpgrade();
    108 
    109105    IDBError ensureValidRecordsTable();
    110106    IDBError ensureValidIndexRecordsTable();
    … …  
    207203    std::unique_ptr<SQLiteStatement> m_cachedStatements[static_cast<int>(SQL::Invalid)];
    208204
    209     PAL::SessionID m_sessionID;
    210205    IDBDatabaseIdentifier m_identifier;
    211206    std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;
    … …  
    217212    HashMap<IDBResourceIdentifier, SQLiteIDBCursor*> m_cursors;
    218213
    219     String m_databaseRootDirectory;
    220214    String m_databaseDirectory;
    221215};

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp

    r284857 r289474  
    4343#include "StorageQuotaManager.h"
    4444#include "UniqueIDBDatabaseConnection.h"
     45#include "UniqueIDBDatabaseManager.h"
    4546#include <wtf/Scope.h>
    4647
    … …  
    135136}
    136137
    137 UniqueIDBDatabase::UniqueIDBDatabase(IDBServer& server, const IDBDatabaseIdentifier& identifier)
    138     : m_server(server)
     138UniqueIDBDatabase::UniqueIDBDatabase(UniqueIDBDatabaseManager& manager, const IDBDatabaseIdentifier& identifier)
     139    : m_manager(manager)
    139140    , m_identifier(identifier)
    140141{
    … …  
    164165}
    165166
     167UniqueIDBDatabaseManager* UniqueIDBDatabase::manager()
     168{
     169    return m_manager.get();
     170}
     171
    166172void UniqueIDBDatabase::openDatabaseConnection(IDBConnectionToClient& connection, const IDBRequestData& requestData)
    167173{
    … …  
    186192    ASSERT(m_currentOpenDBRequest->isOpenRequest());
    187193
     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
     218void UniqueIDBDatabase::performCurrentOpenOperationAfterSpaceCheck(bool isGranted)
     219{
     220    LOG(IndexedDB, "UniqueIDBDatabase::performCurrentOpenOperationAfterSpaceRequest (%p)", this);
     221
    188222    IDBError backingStoreOpenError;
    189223    if (!m_backingStore) {
    190         // Quota check.
    191         auto decision = m_server.requestSpace(m_identifier.origin(), defaultWriteOperationCost);
    192         if (decision == StorageQuotaManager::Decision::Deny)
     224        if (!m_manager)
     225            backingStoreOpenError = IDBError { InvalidStateError };
     226        else if (!isGranted)
    193227            backingStoreOpenError = IDBError { QuotaExceededError, quotaErrorMessageName("OpenBackingStore") };
    194228        else {
    195             m_backingStore = m_server.createBackingStore(m_identifier);
     229            m_backingStore = m_manager->createBackingStore(m_identifier);
    196230            IDBDatabaseInfo databaseInfo;
    197231            backingStoreOpenError = m_backingStore->getOrEstablishDatabaseInfo(databaseInfo);
    198             if (backingStoreOpenError.isNull())
     232            if (!backingStoreOpenError)
    199233                m_databaseInfo = makeUnique<IDBDatabaseInfo>(databaseInfo);
    200234            else {
    … …  
    205239    }
    206240
    207     if (!backingStoreOpenError.isNull()) {
     241    if (backingStoreOpenError) {
    208242        auto result = IDBResultData::error(m_currentOpenDBRequest->requestData().requestIdentifier(), backingStoreOpenError);
    209243        m_currentOpenDBRequest->connection().didOpenDatabase(result);
    … …  
    295329    LOG(IndexedDB, "UniqueIDBDatabase::deleteBackingStore");
    296330   
    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);
    298332    uint64_t deletedVersion = backingStore->databaseVersion();
    299333    backingStore->deleteBackingStore();
    … …  
    543577}
    544578
    545 void UniqueIDBDatabase::createObjectStore(UniqueIDBDatabaseTransaction& transaction, const IDBObjectStoreInfo& info, ErrorCallback callback)
     579void UniqueIDBDatabase::createObjectStore(UniqueIDBDatabaseTransaction& transaction, const IDBObjectStoreInfo& info, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    546580{
    547581    ASSERT(!isMainThread());
    548582    LOG(IndexedDB, "UniqueIDBDatabase::createObjectStore");
    549583
    550     ASSERT(m_backingStore);
    551 
    552     // Quota check.
    553     auto taskSize = defaultWriteOperationCost + estimateSize(info);
    554     if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {
     584    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     593        });
     594        return;
     595    }
     596
     597    if (spaceCheckResult != SpaceCheckResult::Pass) {
    555598        callback(IDBError { QuotaExceededError, quotaErrorMessageName("CreateObjectStore") });
    556599        return;
    557600    }
     601
     602    if (!m_backingStore)
     603        return callback(IDBError { InvalidStateError, "Backing store has closed" });
    558604
    559605    auto error = m_backingStore->createObjectStore(transaction.info().identifier(), info);
    … …  
    564610}
    565611
    566 void UniqueIDBDatabase::deleteObjectStore(UniqueIDBDatabaseTransaction& transaction, const String& objectStoreName, ErrorCallback callback)
     612void UniqueIDBDatabase::deleteObjectStore(UniqueIDBDatabaseTransaction& transaction, const String& objectStoreName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    567613{
    568614    ASSERT(!isMainThread());
    569615    LOG(IndexedDB, "UniqueIDBDatabase::deleteObjectStore");
    570616
     617    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     626        });
     627        return;
     628    }
     629
     630    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
    571631    auto* info = m_databaseInfo->infoForExistingObjectStore(objectStoreName);
    572632    if (!info) {
    … …  
    575635    }
    576636
    577     ASSERT(m_backingStore);
     637    if (!m_backingStore)
     638        return callback(IDBError { InvalidStateError, "Backing store is closed" });
     639
    578640    auto error = m_backingStore->deleteObjectStore(transaction.info().identifier(), info->identifier());
    579641    if (error.isNull())
    … …  
    583645}
    584646
    585 void UniqueIDBDatabase::renameObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback callback)
     647void UniqueIDBDatabase::renameObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    586648{
    587649    ASSERT(!isMainThread());
    588650    LOG(IndexedDB, "UniqueIDBDatabase::renameObjectStore");
    589651
    590     // Quota check.
    591     auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
    592     if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {
     652    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     653        if (!m_manager)
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     662        });
     663        return;
     664    }
     665
     666    if (spaceCheckResult != SpaceCheckResult::Pass) {
    593667        callback(IDBError(QuotaExceededError, quotaErrorMessageName("RenameObjectStore")));
    594668        return;
    … …  
    601675    }
    602676
    603     ASSERT(m_backingStore);
     677    if (!m_backingStore)
     678        return callback(IDBError { InvalidStateError, "Backing store is closed" });
     679
    604680    auto error = m_backingStore->renameObjectStore(transaction.info().identifier(), objectStoreIdentifier, newName);
    605681    if (error.isNull())
    … …  
    609685}
    610686
    611 void UniqueIDBDatabase::clearObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, ErrorCallback callback)
     687void UniqueIDBDatabase::clearObjectStore(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    612688{
    613689    ASSERT(!isMainThread());
    614690    LOG(IndexedDB, "UniqueIDBDatabase::clearObjectStore");
    615691
    616     ASSERT(m_backingStore);
     692    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     701        });
     702        return;
     703    }
     704
     705    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     706    if (!m_backingStore)
     707        return callback(IDBError { InvalidStateError, "Backing store is closed" });
     708
    617709    auto error = m_backingStore->clearObjectStore(transaction.info().identifier(), objectStoreIdentifier);
    618 
    619710    callback(error);
    620711}
    621712
    622 void UniqueIDBDatabase::createIndex(UniqueIDBDatabaseTransaction& transaction, const IDBIndexInfo& info, ErrorCallback callback)
     713void UniqueIDBDatabase::createIndex(UniqueIDBDatabaseTransaction& transaction, const IDBIndexInfo& info, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    623714{
    624715    ASSERT(!isMainThread());
    625716    LOG(IndexedDB, "UniqueIDBDatabase::createIndex");
    626717
    627     // Quota check.
    628     auto taskSize = defaultWriteOperationCost + estimateSize(info);
    629     if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {
     718    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     719        if (!m_manager)
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     728        });
     729        return;
     730    }
     731
     732    if (spaceCheckResult != SpaceCheckResult::Pass) {
    630733        callback(IDBError { QuotaExceededError, quotaErrorMessageName("CreateIndex") });
    631734        return;
    632735    }
    633736
    634     ASSERT(m_backingStore);
     737    if (!m_backingStore)
     738        return callback(IDBError { InvalidStateError, "Backing store is closed" });
     739
    635740    auto error = m_backingStore->createIndex(transaction.info().identifier(), info);
    636741    if (error.isNull()) {
    … …  
    645750}
    646751
    647 void UniqueIDBDatabase::deleteIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback callback)
     752void UniqueIDBDatabase::deleteIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    648753{
    649754    ASSERT(!isMainThread());
    650755    LOG(IndexedDB, "UniqueIDBDatabase::deleteIndex");
     756
     757    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     766        });
     767        return;
     768    }
     769
     770    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     771    if (!m_backingStore)
     772        return callback(IDBError { InvalidStateError, "Backing store is closed" });
    651773
    652774    auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
    … …  
    661783        return;
    662784    }
     785
    663786    auto indexIdentifier = indexInfo->identifier();
    664 
    665     ASSERT(m_backingStore);
    666787    auto error = m_backingStore->deleteIndex(transaction.info().identifier(), objectStoreIdentifier, indexIdentifier);
    667788    if (error.isNull())
    … …  
    671792}
    672793
    673 void UniqueIDBDatabase::renameIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback callback)
     794void UniqueIDBDatabase::renameIndex(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    674795{
    675796    ASSERT(!isMainThread());
    676797    LOG(IndexedDB, "UniqueIDBDatabase::renameIndex");
    677798
    678     // Quota check.
    679     auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
    680     if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {
     799    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     800        if (!m_manager)
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     809        });
     810        return;
     811    }
     812
     813    if (spaceCheckResult != SpaceCheckResult::Pass) {
    681814        callback(IDBError { QuotaExceededError, quotaErrorMessageName("RenameIndex") });
    682815        return;
    683816    }
     817
     818    if (!m_backingStore)
     819        return callback(IDBError { InvalidStateError, "Backing store is closed" });
    684820
    685821    auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
    … …  
    695831    }
    696832
    697     ASSERT(m_backingStore);
    698833    auto error = m_backingStore->renameIndex(transaction.info().identifier(), objectStoreIdentifier, indexIdentifier, newName);
    699834    if (error.isNull())
    … …  
    710845    ASSERT(m_databaseInfo);
    711846
     847    if (!m_backingStore)
     848        return callback(IDBError { InvalidStateError, "Backing store is closed" }, keyData);
     849
     850    auto objectStoreIdentifier = requestData.objectStoreIdentifier();
     851    auto* objectStoreInfo = m_backingStore->infoForObjectStore(objectStoreIdentifier);
     852    if (!objectStoreInfo)
     853        return callback(IDBError { InvalidStateError, "Object store cannot be found in the backing store"_s }, keyData);
     854
     855    if (!m_manager)
     856        return callback(IDBError { InvalidStateError }, keyData);
     857
    712858    IDBKeyData usedKey;
    713859    IDBError error;
    714 
    715     ASSERT(m_backingStore);
    716     auto objectStoreIdentifier = requestData.objectStoreIdentifier();
    717     auto* objectStoreInfo = m_backingStore->infoForObjectStore(objectStoreIdentifier);
    718     if (!objectStoreInfo) {
    719         callback(IDBError { InvalidStateError, "Object store cannot be found in the backing store"_s }, usedKey);
    720         return;
    721     }
    722 
    723860    bool usedKeyIsGenerated = false;
    724861    uint64_t keyNumber;
    … …  
    731868    if (objectStoreInfo->autoIncrement() && !keyData.isValid()) {
    732869        error = m_backingStore->generateKeyNumber(transactionIdentifier, objectStoreIdentifier, keyNumber);
    733         if (!error.isNull()) {
    734             callback(error, usedKey);
    735             return;
    736         }
     870        if (!error.isNull())
     871            return callback(error, usedKey);
     872
    737873        usedKey.setNumberValue(keyNumber);
    738874        usedKeyIsGenerated = true;
    739875    } else
    740876        usedKey = keyData;
     877
     878    if (overwriteMode == IndexedDB::ObjectStoreOverwriteMode::NoOverwrite) {
     879        bool keyExists;
     880        error = m_backingStore->keyExistsInObjectStore(transactionIdentifier, objectStoreIdentifier, usedKey, keyExists);
     881        if (!error && keyExists)
     882            error = IDBError { ConstraintError, "Key already exists in the object store"_s };
     883
     884        if (!!error)
     885            return callback(error, usedKey);
     886    }
    741887
    742888    // Generate index keys up front for more accurate quota check.
    … …  
    746892    });
    747893
    748     if (overwriteMode == IndexedDB::ObjectStoreOverwriteMode::NoOverwrite) {
    749         bool keyExists;
    750         error = m_backingStore->keyExistsInObjectStore(transactionIdentifier, objectStoreIdentifier, usedKey, keyExists);
    751         if (error.isNull() && keyExists)
    752             error = IDBError { ConstraintError, "Key already exists in the object store"_s };
    753 
    754         if (!error.isNull()) {
    755             callback(error, usedKey);
    756             return;
    757         }
    758     }
    759 
    760     // Quota check.
     894    generatedKeyResetter.release();
    761895    auto keySize = estimateSize(usedKey);
    762896    auto valueSize = estimateSize(value);
    … …  
    765899
    766900    LOG(IndexedDB, "UniqueIDBDatabase::putOrAdd quota check with task size: %" PRIu64 " key size: %" PRIu64 " value size: %" PRIu64 " index size: %" PRIu64, taskSize, keySize, valueSize, indexSize);
    767 
    768     if (m_server.requestSpace(m_identifier.origin(), taskSize) == StorageQuotaManager::Decision::Deny) {
    769         callback(IDBError { QuotaExceededError, quotaErrorMessageName("PutOrAdd") }, usedKey);
    770         return;
    771     }
    772 
     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);
     904
     905        putOrAddAfterSpaceCheck(requestData, usedKey, value, overwriteMode, WTFMove(callback), usedKeyIsGenerated, indexKeys, objectStoreInfo, granted ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     906    });
     907}
     908
     909void 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    });
     924
     925    if (spaceCheckResult != SpaceCheckResult::Pass)
     926        return callback(IDBError { QuotaExceededError, quotaErrorMessageName("PutOrAdd") }, keyData);
    773927    // 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.
    775     error = m_backingStore->deleteRange(transactionIdentifier, objectStoreIdentifier, usedKey);
    776     if (!error.isNull()) {
    777         callback(error, usedKey);
    778         return;
    779     }
    780 
    781     error = m_backingStore->addRecord(transactionIdentifier, *objectStoreInfo, usedKey, indexKeys, value);
    782     if (!error.isNull()) {
    783         callback(error, usedKey);
    784         return;
    785     }
    786 
    787     if (overwriteMode != IndexedDB::ObjectStoreOverwriteMode::OverwriteForCursor && objectStoreInfo->autoIncrement() && keyData.type() == IndexedDB::KeyType::Number)
     928    // This is important because formally deleting it from the object store also removes it from the appropriate indexes.
     929    IDBError error = m_backingStore->deleteRange(transactionIdentifier, objectStoreIdentifier, keyData);
     930    if (!error.isNull())
     931        return callback(error, keyData);
     932
     933    error = m_backingStore->addRecord(transactionIdentifier, objectStoreInfo, keyData, indexKeys, value);
     934    if (!error.isNull())
     935        return callback(error, keyData);
     936
     937    if (overwriteMode != IndexedDB::ObjectStoreOverwriteMode::OverwriteForCursor && objectStoreInfo.autoIncrement() && keyData.type() == IndexedDB::KeyType::Number)
    788938        error = m_backingStore->maybeUpdateKeyGeneratorNumber(transactionIdentifier, objectStoreIdentifier, keyData.number());
    789939
    790940    generatedKeyResetter.release();
    791     callback(error, usedKey);
    792 }
    793 
    794 void UniqueIDBDatabase::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback)
     941    callback(error, keyData);
     942}
     943
     944void UniqueIDBDatabase::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback, SpaceCheckResult spaceCheckResult)
    795945{
    796946    ASSERT(!isMainThread());
    797947    LOG(IndexedDB, "UniqueIDBDatabase::getRecord");
     948
     949    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     958        });
     959        return;
     960    }
     961
     962    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     963    if (!m_backingStore)
     964        return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetResult { });
    798965
    799966    IDBGetResult result;
    800967    IDBError error;
    801968
    802     ASSERT(m_backingStore);
    803969    if (uint64_t indexIdentifier = requestData.indexIdentifier())
    804970        error = m_backingStore->getIndexRecord(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), indexIdentifier, requestData.indexRecordType(), getRecordData.keyRangeData, result);
    … …  
    809975}
    810976
    811 void UniqueIDBDatabase::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback)
     977void UniqueIDBDatabase::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback, SpaceCheckResult spaceCheckResult)
    812978{
    813979    ASSERT(!isMainThread());
    814980    LOG(IndexedDB, "UniqueIDBDatabase::getAllRecords");
    815981
    816     ASSERT(m_backingStore);
     982    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     991        });
     992        return;
     993    }
     994
     995    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     996    if (!m_backingStore)
     997        return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetAllResult { });
     998
    817999    IDBGetAllResult result;
    8181000    auto error = m_backingStore->getAllRecords(requestData.transactionIdentifier(), getAllRecordsData, result);
    … …  
    8211003}
    8221004
    823 void UniqueIDBDatabase::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback)
     1005void UniqueIDBDatabase::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback, SpaceCheckResult spaceCheckResult)
    8241006{
    8251007    ASSERT(!isMainThread());
    8261008    LOG(IndexedDB, "UniqueIDBDatabase::getCount");
    8271009
    828     ASSERT(m_backingStore);
     1010    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     1019        });
     1020        return;
     1021    }
     1022
     1023    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     1024    if (!m_backingStore)
     1025        return callback(IDBError { InvalidStateError, "Backing store is closed" }, 0);
     1026
    8291027    uint64_t count = 0;
    8301028    auto error = m_backingStore->getCount(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), requestData.indexIdentifier(), range, count);
    … …  
    8331031}
    8341032
    835 void UniqueIDBDatabase::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback)
     1033void UniqueIDBDatabase::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    8361034{
    8371035    ASSERT(!isMainThread());
    8381036    LOG(IndexedDB, "UniqueIDBDatabase::deleteRecord");
    8391037
    840     ASSERT(m_backingStore);
     1038    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     1047        });
     1048        return;
     1049    }
     1050
     1051    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     1052    if (!m_backingStore)
     1053        return callback(IDBError { InvalidStateError, "Backing store is closed" });
     1054
    8411055    auto error = m_backingStore->deleteRange(requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), keyRangeData);
    8421056
    … …  
    8441058}
    8451059
    846 void UniqueIDBDatabase::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback)
     1060void UniqueIDBDatabase::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback, SpaceCheckResult spaceCheckResult)
    8471061{
    8481062    ASSERT(!isMainThread());
    8491063    LOG(IndexedDB, "UniqueIDBDatabase::openCursor");
    8501064
    851     ASSERT(m_backingStore);
     1065    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     1074        });
     1075        return;
     1076    }
     1077
     1078    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     1079    if (!m_backingStore)
     1080        return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetResult { });
    8521081
    8531082    IDBGetResult result;
    … …  
    8571086}
    8581087
    859 void UniqueIDBDatabase::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback)
     1088void UniqueIDBDatabase::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback, SpaceCheckResult spaceCheckResult)
    8601089{
    8611090    ASSERT(!isMainThread());
    8621091    LOG(IndexedDB, "UniqueIDBDatabase::iterateCursor");
    8631092
    864     ASSERT(m_backingStore);
     1093    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     1102        });
     1103        return;
     1104    }
     1105
     1106    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
     1107    if (!m_backingStore)
     1108        return callback(IDBError { InvalidStateError, "Backing store is closed" }, IDBGetResult { });
    8651109
    8661110    IDBGetResult result;
    … …  
    8721116}
    8731117
    874 void UniqueIDBDatabase::commitTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)
     1118void UniqueIDBDatabase::commitTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    8751119{
    8761120    ASSERT(!isMainThread());
    8771121    LOG(IndexedDB, "UniqueIDBDatabase::commitTransaction - %s", transaction.info().identifier().loggingString().utf8().data());
    8781122
     1123    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     1132        });
     1133        return;
     1134    }
     1135
     1136    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
    8791137    ASSERT(transaction.databaseConnection().database() == this);
    880     ASSERT(m_backingStore);
     1138
     1139    if (!m_backingStore)
     1140        return callback(IDBError { InvalidStateError, "Backing store is closed" });
     1141
    8811142    auto takenTransaction = m_inProgressTransactions.take(transaction.info().identifier());
    8821143    if (!takenTransaction) {
    … …  
    8941155}
    8951156
    896 void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)
     1157void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback, SpaceCheckResult spaceCheckResult)
    8971158{
    8981159    ASSERT(!isMainThread());
    8991160    LOG(IndexedDB, "UniqueIDBDatabase::abortTransaction - %s", transaction.info().identifier().loggingString().utf8().data());
    9001161
     1162    if (spaceCheckResult == SpaceCheckResult::Unknown) {
     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 ? SpaceCheckResult::Pass : SpaceCheckResult::Fail);
     1171        });
     1172        return;
     1173    }
     1174
     1175    ASSERT(spaceCheckResult == SpaceCheckResult::Pass);
    9011176    ASSERT(transaction.databaseConnection().database() == this);
    9021177
    … …  
    9261201    }
    9271202
    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);
    9291208
    9301209    callback(error);
    … …  
    12261505    return true;
    12271506}
     1507   
     1508bool UniqueIDBDatabase::hasDataInMemory() const
     1509{
     1510    return m_backingStore ? m_backingStore->isEphemeral() : false;
     1511}
    12281512
    12291513RefPtr<ServerOpenDBRequest> UniqueIDBDatabase::takeNextRunnableRequest(RequestType requestType)

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h

    r280410 r289474  
    6060
    6161class IDBConnectionToClient;
    62 class IDBServer;
    6362class UniqueIDBDatabaseConnection;
     63class UniqueIDBDatabaseManager;
    6464
    6565typedef Function<void(const IDBError&)> ErrorCallback;
    … …  
    7272    WTF_MAKE_FAST_ALLOCATED;
    7373public:
    74     UniqueIDBDatabase(IDBServer&, const IDBDatabaseIdentifier&);
     74    WEBCORE_EXPORT UniqueIDBDatabase(UniqueIDBDatabaseManager&, const IDBDatabaseIdentifier&);
    7575    UniqueIDBDatabase(UniqueIDBDatabase&) = delete;
    7676    WEBCORE_EXPORT ~UniqueIDBDatabase();
    7777
    78     void openDatabaseConnection(IDBConnectionToClient&, const IDBRequestData&);
     78    WEBCORE_EXPORT void openDatabaseConnection(IDBConnectionToClient&, const IDBRequestData&);
    7979
    8080    const IDBDatabaseInfo& info() const;
    81     IDBServer& server() { return m_server; }
     81    UniqueIDBDatabaseManager* manager();
    8282    const IDBDatabaseIdentifier& identifier() const { return m_identifier; }
    8383
    84     void createObjectStore(UniqueIDBDatabaseTransaction&, const IDBObjectStoreInfo&, ErrorCallback);
    85     void deleteObjectStore(UniqueIDBDatabaseTransaction&, const String& objectStoreName, ErrorCallback);
    86     void renameObjectStore(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback);
    87     void clearObjectStore(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, ErrorCallback);
    88     void createIndex(UniqueIDBDatabaseTransaction&, const IDBIndexInfo&, ErrorCallback);
    89     void deleteIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback);
    90     void renameIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback);
     84    enum class SpaceCheckResult : uint8_t {
     85        Unknown,
     86        Pass,
     87        Fail
     88    };
     89    void createObjectStore(UniqueIDBDatabaseTransaction&, const IDBObjectStoreInfo&, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     90    void deleteObjectStore(UniqueIDBDatabaseTransaction&, const String& objectStoreName, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     91    void renameObjectStore(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     92    void clearObjectStore(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     93    void createIndex(UniqueIDBDatabaseTransaction&, const IDBIndexInfo&, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     94    void deleteIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     95    void renameIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
    9196    void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback);
    92     void getRecord(const IDBRequestData&, const IDBGetRecordData&, GetResultCallback);
    93     void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&, GetAllResultsCallback);
    94     void getCount(const IDBRequestData&, const IDBKeyRangeData&, CountCallback);
    95     void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&, ErrorCallback);
    96     void openCursor(const IDBRequestData&, const IDBCursorInfo&, GetResultCallback);
    97     void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback);
    98     void commitTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
    99     void abortTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
     97    void putOrAddAfterSpaceCheck(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback, bool isKeyGenerated, const IndexIDToIndexKeyMap&, const IDBObjectStoreInfo&, SpaceCheckResult);
     98    void getRecord(const IDBRequestData&, const IDBGetRecordData&, GetResultCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     99    void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&, GetAllResultsCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     100    void getCount(const IDBRequestData&, const IDBKeyRangeData&, CountCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     101    void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     102    void openCursor(const IDBRequestData&, const IDBCursorInfo&, GetResultCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     103    void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     104    void commitTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
     105    void abortTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback, SpaceCheckResult = SpaceCheckResult::Unknown);
    100106
    101107    void didFinishHandlingVersionChange(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& transactionIdentifier);
    102108    void connectionClosedFromClient(UniqueIDBDatabaseConnection&);
    103109    void didFireVersionChangeEvent(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& requestIdentifier, IndexedDB::ConnectionClosedOnBehalfOfServer);
    104     void openDBRequestCancelled(const IDBResourceIdentifier& requestIdentifier);
     110    WEBCORE_EXPORT void openDBRequestCancelled(const IDBResourceIdentifier& requestIdentifier);
    105111
    106112    void enqueueTransaction(Ref<UniqueIDBDatabaseTransaction>&&);
    107113
    108     void handleDelete(IDBConnectionToClient&, const IDBRequestData&);
    109     void immediateClose();
     114    WEBCORE_EXPORT void handleDelete(IDBConnectionToClient&, const IDBRequestData&);
     115    WEBCORE_EXPORT void immediateClose();
    110116
    111117    bool hasActiveTransactions() const;
    112     void abortActiveTransactions();
    113     bool tryClose();
     118    WEBCORE_EXPORT void abortActiveTransactions();
     119    WEBCORE_EXPORT bool tryClose();
    114120
    115     String filePath() const;
    116     std::optional<IDBDatabaseNameAndVersion> nameAndVersion() const;
     121    WEBCORE_EXPORT String filePath() const;
     122    WEBCORE_EXPORT std::optional<IDBDatabaseNameAndVersion> nameAndVersion() const;
     123    WEBCORE_EXPORT bool hasDataInMemory() const;
    117124
    118125private:
    … …  
    120127    void handleCurrentOperation();
    121128    void performCurrentOpenOperation();
     129    void performCurrentOpenOperationAfterSpaceCheck(bool isGranted);
    122130    void performCurrentDeleteOperation();
    123131    enum class RequestType { Delete, Any };
    … …  
    147155    void clearTransactionsOnConnection(UniqueIDBDatabaseConnection&);
    148156
    149     IDBServer& m_server;
     157    IDBServer* m_server;
     158    WeakPtr<UniqueIDBDatabaseManager> m_manager;
    150159    IDBDatabaseIdentifier m_identifier;
    151160
    152161    ListHashSet<RefPtr<ServerOpenDBRequest>> m_pendingOpenDBRequests;
    153162    RefPtr<ServerOpenDBRequest> m_currentOpenDBRequest;
     163    HashSet<IDBResourceIdentifier> m_openDBRequestsForSpaceCheck;
    154164
    155165    ListHashSet<RefPtr<UniqueIDBDatabaseConnection>> m_openDatabaseConnections;

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp

    r284057 r289474  
    3232#include "ServerOpenDBRequest.h"
    3333#include "UniqueIDBDatabase.h"
     34#include "UniqueIDBDatabaseManager.h"
    3435
    3536namespace WebCore {
    … …  
    4344UniqueIDBDatabaseConnection::UniqueIDBDatabaseConnection(UniqueIDBDatabase& database, ServerOpenDBRequest& request)
    4445    : m_database(database)
    45     , m_server(database.server())
     46    , m_manager(database.manager())
    4647    , m_connectionToClient(request.connection())
    4748    , m_openRequestIdentifier(request.requestData().requestIdentifier())
    4849{
    49     m_server.registerDatabaseConnection(*this);
     50    if (auto* manager = database.manager()) {
     51        m_manager = *manager;
     52        m_manager->registerConnection(*this);
     53    }
    5054    m_connectionToClient->registerDatabaseConnection(*this);
    5155}
    … …  
    5559    ASSERT(m_transactionMap.isEmpty());
    5660
    57     m_server.unregisterDatabaseConnection(*this);
     61    if (m_manager)
     62        m_manager->unregisterConnection(*this);
    5863    m_connectionToClient->unregisterDatabaseConnection(*this);
     64}
     65
     66UniqueIDBDatabaseManager* UniqueIDBDatabaseConnection::manager()
     67{
     68    return m_manager.get();
    5969}
    6070

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h

    r279960 r289474  
    2626#pragma once
    2727
    28 #include "IDBServer.h"
    2928#include "UniqueIDBDatabase.h"
    3029#include <wtf/HashMap.h>
    … …  
    3736class IDBError;
    3837class IDBResultData;
     38class UniqueIDBDatabaseManager;
    3939
    4040namespace IDBServer {
    … …  
    5353    const IDBResourceIdentifier& openRequestIdentifier() { return m_openRequestIdentifier; }
    5454    UniqueIDBDatabase* database() { return m_database.get(); }
    55     IDBServer* server() { return &m_server; }
     55    UniqueIDBDatabaseManager* manager();
    5656    IDBConnectionToClient& connectionToClient() { return m_connectionToClient; }
    5757
    58     void connectionPendingCloseFromClient();
    59     void connectionClosedFromClient();
     58    WEBCORE_EXPORT void connectionPendingCloseFromClient();
     59    WEBCORE_EXPORT void connectionClosedFromClient();
    6060
    6161    bool closePending() const { return m_closePending; }
    … …  
    6666    UniqueIDBDatabaseTransaction& createVersionChangeTransaction(uint64_t newVersion);
    6767
    68     void establishTransaction(const IDBTransactionInfo&);
     68    WEBCORE_EXPORT void establishTransaction(const IDBTransactionInfo&);
    6969    void didAbortTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);
    7070    void didCommitTransaction(UniqueIDBDatabaseTransaction&, const IDBError&);
    … …  
    7676    void didDeleteIndex(const IDBResultData&);
    7777    void didRenameIndex(const IDBResultData&);
    78     void didFireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, IndexedDB::ConnectionClosedOnBehalfOfServer);
    79     void didFinishHandlingVersionChange(const IDBResourceIdentifier& transactionIdentifier);
     78    WEBCORE_EXPORT void didFireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, IndexedDB::ConnectionClosedOnBehalfOfServer);
     79    WEBCORE_EXPORT void didFinishHandlingVersionChange(const IDBResourceIdentifier& transactionIdentifier);
    8080
    8181    void abortTransactionWithoutCallback(UniqueIDBDatabaseTransaction&);
    … …  
    8989
    9090    WeakPtr<UniqueIDBDatabase> m_database;
    91     IDBServer& m_server;
     91    WeakPtr<UniqueIDBDatabaseManager> m_manager;
    9292    Ref<IDBConnectionToClient> m_connectionToClient;
    9393    IDBResourceIdentifier m_openRequestIdentifier;

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp

    r284057 r289474  
    2929#include "IDBIterateCursorData.h"
    3030#include "IDBResultData.h"
    31 #include "IDBServer.h"
    3231#include "Logging.h"
    3332#include "UniqueIDBDatabase.h"
    … …  
    5150        m_originalDatabaseInfo = makeUnique<IDBDatabaseInfo>(database->info());
    5251
    53     databaseConnection().server()->registerTransaction(*this);
     52    if (auto* manager = databaseConnection().manager())
     53        manager->registerTransaction(*this);
    5454}
    5555
    5656UniqueIDBDatabaseTransaction::~UniqueIDBDatabaseTransaction()
    5757{
    58     databaseConnection().server()->unregisterTransaction(*this);
     58    if (auto* manager = databaseConnection().manager())
     59        manager->unregisterTransaction(*this);
    5960}
    6061

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h

    r280053 r289474  
    5252class UniqueIDBDatabaseConnection;
    5353
    54 class UniqueIDBDatabaseTransaction : public RefCounted<UniqueIDBDatabaseTransaction> {
     54class UniqueIDBDatabaseTransaction : public CanMakeWeakPtr<UniqueIDBDatabaseTransaction>, public RefCounted<UniqueIDBDatabaseTransaction> {
    5555public:
    5656    static Ref<UniqueIDBDatabaseTransaction> create(UniqueIDBDatabaseConnection&, const IDBTransactionInfo&);
    … …  
    6060    UniqueIDBDatabaseConnection& databaseConnection();
    6161    const IDBTransactionInfo& info() const { return m_transactionInfo; }
    62     bool isVersionChange() const;
     62    WEBCORE_EXPORT bool isVersionChange() const;
    6363    bool isReadOnly() const;
    6464
    6565    IDBDatabaseInfo* originalDatabaseInfo() const;
    6666
    67     void abort();
    68     void abortWithoutCallback();
    69     void commit(uint64_t pendingRequestCount);
     67    WEBCORE_EXPORT void abort();
     68    WEBCORE_EXPORT void abortWithoutCallback();
     69    WEBCORE_EXPORT void commit(uint64_t pendingRequestCount);
    7070
    71     void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&);
    72     void deleteObjectStore(const IDBRequestData&, const String& objectStoreName);
    73     void renameObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);
    74     void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier);
    75     void createIndex(const IDBRequestData&, const IDBIndexInfo&);
    76     void deleteIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);
    77     void renameIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);
    78     void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode);
    79     void getRecord(const IDBRequestData&, const IDBGetRecordData&);
    80     void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&);
    81     void getCount(const IDBRequestData&, const IDBKeyRangeData&);
    82     void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&);
    83     void openCursor(const IDBRequestData&, const IDBCursorInfo&);
    84     void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&);
     71    WEBCORE_EXPORT void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&);
     72    WEBCORE_EXPORT void deleteObjectStore(const IDBRequestData&, const String& objectStoreName);
     73    WEBCORE_EXPORT void renameObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);
     74    WEBCORE_EXPORT void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier);
     75    WEBCORE_EXPORT void createIndex(const IDBRequestData&, const IDBIndexInfo&);
     76    WEBCORE_EXPORT void deleteIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);
     77    WEBCORE_EXPORT void renameIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);
     78    WEBCORE_EXPORT void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode);
     79    WEBCORE_EXPORT void getRecord(const IDBRequestData&, const IDBGetRecordData&);
     80    WEBCORE_EXPORT void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&);
     81    WEBCORE_EXPORT void getCount(const IDBRequestData&, const IDBKeyRangeData&);
     82    WEBCORE_EXPORT void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&);
     83    WEBCORE_EXPORT void openCursor(const IDBRequestData&, const IDBCursorInfo&);
     84    WEBCORE_EXPORT void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&);
    8585
    8686    void didActivateInBackingStore(const IDBError&);

  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBError.h

    r278253 r289474  
    5353
    5454    bool isNull() const { return !m_code; }
     55    operator bool() const { return !isNull(); }
    5556
    5657    WEBCORE_EXPORT IDBError isolatedCopy() const;

  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.h

    r278253 r289474  
    5757
    5858    IDBConnectionIdentifier serverConnectionIdentifier() const;
    59     IDBResourceIdentifier requestIdentifier() const;
    60     IDBResourceIdentifier transactionIdentifier() const;
     59    WEBCORE_EXPORT IDBResourceIdentifier requestIdentifier() const;
     60    WEBCORE_EXPORT IDBResourceIdentifier transactionIdentifier() const;
    6161    uint64_t objectStoreIdentifier() const;
    6262    uint64_t indexIdentifier() const;

  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h

    r276502 r289474  
    5050    explicit IDBResourceIdentifier(const IDBServer::IDBConnectionToClient&);
    5151
    52     static IDBResourceIdentifier emptyValue();
     52    WEBCORE_EXPORT static IDBResourceIdentifier emptyValue();
    5353    bool isEmpty() const
    5454    {
    … …  
    6161        return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
    6262    }
    63    
     63
     64    bool operator!=(const IDBResourceIdentifier& other) const { return !(*this == other); }
    6465    bool operator==(const IDBResourceIdentifier& other) const
    6566    {

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r289356 r289474  
    15451545                5117F30E25E61020002A9F1E /* RemoteCommandListenerCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 5117F30C25E6101F002A9F1E /* RemoteCommandListenerCocoa.h */; };
    15461546                511EC1281C50AACA0032F983 /* IDBSerialization.h in Headers */ = {isa = PBXBuildFile; fileRef = 511EC1261C50AA570032F983 /* IDBSerialization.h */; };
    1547                 511EC12C1C50ABBF0032F983 /* SQLiteIDBTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 511EC12A1C50ABBA0032F983 /* SQLiteIDBTransaction.h */; };
     1547                511EC12C1C50ABBF0032F983 /* SQLiteIDBTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 511EC12A1C50ABBA0032F983 /* SQLiteIDBTransaction.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15481548                511EC1301C50ABF50032F983 /* SQLiteIDBCursor.h in Headers */ = {isa = PBXBuildFile; fileRef = 511EC12E1C50ABEC0032F983 /* SQLiteIDBCursor.h */; };
    15491549                5120BBAF1F1CECE700EFEBF1 /* CookieStorageObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 5120BBAD1F1CE77000EFEBF1 /* CookieStorageObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1550                 512BDB4B1C456FFA006494DF /* SQLiteIDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 512BDB491C456FAB006494DF /* SQLiteIDBBackingStore.h */; };
     1550                512BDB4B1C456FFA006494DF /* SQLiteIDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 512BDB491C456FAB006494DF /* SQLiteIDBBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15511551                512DD8F50D91E6AF000F89EE /* LegacyWebArchive.h in Headers */ = {isa = PBXBuildFile; fileRef = 512DD8EB0D91E6AF000F89EE /* LegacyWebArchive.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15521552                512DD8F60D91E6AF000F89EE /* Archive.h in Headers */ = {isa = PBXBuildFile; fileRef = 512DD8EC0D91E6AF000F89EE /* Archive.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    15941594                516F7F6D1C31E39A00F111DC /* ServerOpenDBRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 516F7F6C1C31C79D00F111DC /* ServerOpenDBRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15951595                517138F01BED1D1A000D5F01 /* IndexKey.h in Headers */ = {isa = PBXBuildFile; fileRef = 517138EE1BED1D17000D5F01 /* IndexKey.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1596                 517138F81BF128BB000D5F01 /* IndexValueStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 517138F61BF12262000D5F01 /* IndexValueStore.h */; };
     1596                517138F81BF128BB000D5F01 /* IndexValueStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 517138F61BF12262000D5F01 /* IndexValueStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15971597                517138FC1BF3ADF4000D5F01 /* IDBCursorInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 517138FA1BF3ADAC000D5F01 /* IDBCursorInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15981598                517139061BF64DEC000D5F01 /* MemoryObjectStoreCursor.h in Headers */ = {isa = PBXBuildFile; fileRef = 517139041BF64DE3000D5F01 /* MemoryObjectStoreCursor.h */; };
    … …  
    16701670                51B914111FD2782D00EE2859 /* RegistrationStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 51B9140B1FD2782500EE2859 /* RegistrationStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
    16711671                51BA4AC41BBB5CD800DF3D6D /* IDBDatabaseInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA4AC21BBB5CBF00DF3D6D /* IDBDatabaseInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1672                 51BA4ACB1BBC5BD900DF3D6D /* MemoryIDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA4AC91BBC5B9E00DF3D6D /* MemoryIDBBackingStore.h */; };
     1672                51BA4ACB1BBC5BD900DF3D6D /* MemoryIDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA4AC91BBC5B9E00DF3D6D /* MemoryIDBBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
    16731673                51BA4ACC1BBC5BDD00DF3D6D /* IDBBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA4AC71BBC5AD600DF3D6D /* IDBBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
    16741674                51BA947123AC305300444846 /* RunJavaScriptParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 51BA946F23AC305000444846 /* RunJavaScriptParameters.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    16861686                51E0BAEB0DA55D4A00A9E417 /* JSStorageEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E0BAE90DA55D4A00A9E417 /* JSStorageEvent.h */; };
    16871687                51E0BB380DA5ACB600A9E417 /* StorageMap.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E0BB360DA5ACB600A9E417 /* StorageMap.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1688                 51E1BAC31BD8064E0055D81F /* MemoryBackingStoreTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E1BAC11BD806470055D81F /* MemoryBackingStoreTransaction.h */; };
     1688                51E1BAC31BD8064E0055D81F /* MemoryBackingStoreTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E1BAC11BD806470055D81F /* MemoryBackingStoreTransaction.h */; settings = {ATTRIBUTES = (Private, ); }; };
    16891689                51E269371DD3BD9B006B6A58 /* IDBIterateCursorData.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E269351DD3BD91006B6A58 /* IDBIterateCursorData.h */; settings = {ATTRIBUTES = (Private, ); }; };
    16901690                51E399001D6E4750009C8831 /* GameControllerGamepad.h in Headers */ = {isa = PBXBuildFile; fileRef = 51E398FC1D6E474B009C8831 /* GameControllerGamepad.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    16961696                51ECC3FD2005930D00483EAE /* MessagePortChannelProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 51ECC3FB2005930100483EAE /* MessagePortChannelProvider.h */; settings = {ATTRIBUTES = (Private, ); }; };
    16971697                51EE7B381AA50B0500F92B21 /* ResourceLoadInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 51EE7B371AA50B0500F92B21 /* ResourceLoadInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1698                 51EEAA741BEFFAB100218008 /* IndexValueEntry.h in Headers */ = {isa = PBXBuildFile; fileRef = 51EEAA721BEFFA7900218008 /* IndexValueEntry.h */; };
     1698                51EEAA741BEFFAB100218008 /* IndexValueEntry.h in Headers */ = {isa = PBXBuildFile; fileRef = 51EEAA721BEFFA7900218008 /* IndexValueEntry.h */; settings = {ATTRIBUTES = (Private, ); }; };
    16991699                51F174FE1F35899200C74950 /* WorkerType.h in Headers */ = {isa = PBXBuildFile; fileRef = 51F174FC1F35898800C74950 /* WorkerType.h */; settings = {ATTRIBUTES = (Private, ); }; };
    17001700                51F175031F358B3B00C74950 /* JSServiceWorkerUpdateViaCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 51F175011F358B3600C74950 /* JSServiceWorkerUpdateViaCache.h */; };
    … …  
    29962996                93B38EC325821DB400198E63 /* WebSpeechRecognizerTask.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B38EBA2582193B00198E63 /* WebSpeechRecognizerTask.h */; };
    29972997                93B38EC425821DB700198E63 /* WebSpeechRecognizerTaskMock.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B38EBB2582193D00198E63 /* WebSpeechRecognizerTaskMock.h */; };
     2998                93B631E227ABA1E600443A44 /* UniqueIDBDatabaseManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B631E027ABA1E200443A44 /* UniqueIDBDatabaseManager.h */; settings = {ATTRIBUTES = (Private, ); }; };
    29982999                93B6A0E60B0BCA5C00F5027A /* ContextMenu.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B6A0E50B0BCA5C00F5027A /* ContextMenu.h */; settings = {ATTRIBUTES = (Private, ); }; };
    29993000                93B70D6409EB0C7C009D8468 /* JSDOMBinding.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B70D4809EB0C7C009D8468 /* JSDOMBinding.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    1282912830                93B38EBB2582193D00198E63 /* WebSpeechRecognizerTaskMock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSpeechRecognizerTaskMock.h; sourceTree = "<group>"; };
    1283012831                93B38EBC2582193E00198E63 /* WebSpeechRecognizerTask.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebSpeechRecognizerTask.mm; sourceTree = "<group>"; };
     12832                93B631E027ABA1E200443A44 /* UniqueIDBDatabaseManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueIDBDatabaseManager.h; sourceTree = "<group>"; };
    1283112833                93B6A0E50B0BCA5C00F5027A /* ContextMenu.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ContextMenu.h; sourceTree = "<group>"; };
    1283212834                93B70D4809EB0C7C009D8468 /* JSDOMBinding.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSDOMBinding.h; sourceTree = "<group>"; };
    … …  
    2215222154                                5198F7A21BBDAA2900E2CC5F /* UniqueIDBDatabaseConnection.cpp */,
    2215322155                                5198F7A31BBDAA2900E2CC5F /* UniqueIDBDatabaseConnection.h */,
     22156                                93B631E027ABA1E200443A44 /* UniqueIDBDatabaseManager.h */,
    2215422157                                5198F7A61BBDD38100E2CC5F /* UniqueIDBDatabaseTransaction.cpp */,
    2215522158                                5198F7A71BBDD38100E2CC5F /* UniqueIDBDatabaseTransaction.h */,
    … …  
    3777237775                                518864E11BBAF57400E540C9 /* UniqueIDBDatabase.h in Headers */,
    3777337776                                5198F7A51BBDB79300E2CC5F /* UniqueIDBDatabaseConnection.h in Headers */,
     37777                                93B631E227ABA1E600443A44 /* UniqueIDBDatabaseManager.h in Headers */,
    3777437778                                5198F7A91BBDD38500E2CC5F /* UniqueIDBDatabaseTransaction.h in Headers */,
    3777537779                                E4AFCFA50DAF29A300F5F55C /* UnitBezier.h in Headers */,

  • trunk/Source/WebKit/ChangeLog

    r289469 r289474  
     12022-02-09  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 Chris Dumez.
     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. A new clas IDBStorageRegistry is added 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::ensureConnectionToClient):
     136        (WebKit::IDBStorageRegistry::removeConnectionToClient):
     137        (WebKit::IDBStorageRegistry::registerConnection):
     138        (WebKit::IDBStorageRegistry::unregisterConnection):
     139        (WebKit::IDBStorageRegistry::registerTransaction):
     140        (WebKit::IDBStorageRegistry::unregisterTransaction):
     141        (WebKit::IDBStorageRegistry::connection):
     142        (WebKit::IDBStorageRegistry::transaction):
     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
    12632022-02-09  Lauro Moura  <lmoura@igalia.com>
    2264

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r289247 r289474  
    5353#include "NetworkSocketStream.h"
    5454#include "NetworkSocketStreamMessages.h"
     55#include "NetworkStorageManager.h"
    5556#include "PingLoad.h"
    5657#include "PreconnectTask.h"
    … …  
    5960#include "WebCoreArgumentCoders.h"
    6061#include "WebErrors.h"
    61 #include "WebIDBServer.h"
    6262#include "WebProcessMessages.h"
    6363#include "WebProcessPoolMessages.h"
    … …  
    409409void NetworkConnectionToWebProcess::updateQuotaBasedOnSpaceUsageForTesting(const ClientOrigin& origin)
    410410{
    411     auto storageQuotaManager = m_networkProcess->storageQuotaManager(sessionID(), origin);
    412     storageQuotaManager->resetQuotaUpdatedBasedOnUsageForTesting();
     411    auto* session = m_networkProcess->networkSession(sessionID());
     412    if (!session)
     413        return;
     414
     415    if (auto* storageManager = session->storageManager())
     416        storageManager->resetQuotaUpdatedBasedOnUsageForTesting(origin);
    413417}
    414418
    … …  
    10021006            file->revokeFileAccess();
    10031007
    1004         if (auto* session = networkSession())
    1005             session->ensureWebIDBServer().registerTemporaryBlobFilePaths(m_connection, filePaths);
     1008        if (auto* session = networkSession()) {
     1009            if (auto* storageManager = session->storageManager())
     1010                storageManager->registerTemporaryBlobFilePaths(m_connection, filePaths);
     1011        }
    10061012        completionHandler(WTFMove(filePaths));
    10071013    });

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

    r288950 r289474  
    265265    forEachNetworkSession([&] (auto& session) {
    266266        platformFlushCookies(session.sessionID(), [callbackAggregator] { });
    267         // Make sure reference to NetworkProcess in spaceRequester is removed.
    268         session.closeIDBServer([callbackAggregator] { });
    269267    });
    270268}
    … …  
    383381
    384382    if (auto* session = networkSession(sessionID)) {
    385         session->ensureWebIDBServer().addConnection(connection.connection(), identifier);
    386383        if (auto* manager = session->storageManager())
    387384            manager->startReceivingMessageFromConnection(connection.connection());
    … …  
    407404
    408405    if (auto* session = networkSession(sessionID)) {
    409         session->addStorageManagerSession(parameters.generalStorageDirectory, parameters.generalStorageDirectoryHandle, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle);
    410         session->addIndexedDatabaseSession(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
     406        session->addStorageManagerSession(parameters.generalStorageDirectory, parameters.generalStorageDirectoryHandle, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle, parameters.cacheStorageDirectory, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota);
    411407#if ENABLE(SERVICE_WORKER)
    412408        session->addServiceWorkerSession(parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
    … …  
    14531449#endif
    14541450
    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 
    14621451#if ENABLE(SERVICE_WORKER)
    14631452    if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {
    … …  
    15261515        CacheStorage::Engine::clearAllCaches(*session, [clearTasksHandler] { });
    15271516
    1528     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral() && session)
    1529         session->ensureWebIDBServer().closeAndDeleteDatabasesModifiedSince(modifiedSince, [clearTasksHandler] { });
    1530 
    15311517#if ENABLE(SERVICE_WORKER)
    15321518    bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) || websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
    … …  
    16201606            CacheStorage::Engine::clearCachesForOrigin(*session, SecurityOriginData { originData }, [clearTasksHandler] { });
    16211607    }
    1622 
    1623     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral() && session)
    1624         session->ensureWebIDBServer().closeAndDeleteDatabasesForOrigins(originDatas, [clearTasksHandler] { });
    16251608
    16261609#if ENABLE(SERVICE_WORKER)
    … …  
    18121795        });
    18131796    }
    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     }
    18251797   
    18261798#if ENABLE(SERVICE_WORKER)
    … …  
    19591931    }
    19601932   
    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    
    19681933#if ENABLE(SERVICE_WORKER)
    19691934    if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && session && session->hasServiceWorkerDatabasePath()) {
    … …  
    21302095}
    21312096
    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 
    21612097void NetworkProcess::prepareToSuspend(bool isSuspensionImminent, CompletionHandler<void()>&& completionHandler)
    21622098{
    21632099    RELEASE_LOG(ProcessSuspension, "%p - NetworkProcess::prepareToSuspend(), isSuspensionImminent=%d", this, isSuspensionImminent);
    2164 
    2165 #if PLATFORM(IOS_FAMILY)
    2166     suspendIDBServers(isSuspensionImminent);
    2167 #endif
    21682100
    21692101    lowMemoryHandler(Critical::Yes);
    … …  
    22252157            swServer->endSuspension();
    22262158#endif
    2227 #if PLATFORM(IOS_FAMILY)
    2228         if (auto* server = session.webIDBServer())
    2229             server->resume();
    2230 #endif
    22312159        if (auto* manager = session.storageManager())
    22322160            manager->resume();
    22332161    });
    2234 
    2235 #if PLATFORM(IOS_FAMILY)
    2236     m_shouldSuspendIDBServers = false;
    2237 #endif
    22382162}
    22392163
    … …  
    22822206void NetworkProcess::resetQuota(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
    22832207{
    2284     Locker locker { m_sessionStorageQuotaManagersLock };
    2285     if (auto* sessionStorageQuotaManager = m_sessionStorageQuotaManagers.get(sessionID)) {
    2286         for (auto storageQuotaManager : sessionStorageQuotaManager->existingStorageQuotaManagers())
    2287             storageQuotaManager->resetQuotaForTesting();
    2288     }
    2289     completionHandler();
     2208    auto* session = networkSession(sessionID);
     2209    if (!session)
     2210        return completionHandler();
     2211
     2212    auto* storageManager = session->storageManager();
     2213    if (!storageManager)
     2214        return completionHandler();
     2215
     2216    storageManager->resetQuotaForTesting(WTFMove(completionHandler));
    22902217}
    22912218
    … …  
    22992226}
    23002227
     2228void NetworkProcess::didIncreaseQuota(PAL::SessionID sessionID, const ClientOrigin& origin, QuotaIncreaseRequestIdentifier identifier, std::optional<uint64_t> newQuota)
     2229{
     2230    auto* session = networkSession(sessionID);
     2231    if (!session)
     2232        return;
     2233
     2234    if (auto* manager = session->storageManager())
     2235        manager->didIncreaseQuota(origin, identifier, newQuota);
     2236}
     2237
    23012238void NetworkProcess::renameOriginInWebsiteData(PAL::SessionID sessionID, const URL& oldName, const URL& newName, OptionSet<WebsiteDataType> dataTypes, CompletionHandler<void()>&& completionHandler)
    23022239{
    … …  
    23112248    if (auto* manager = session ? session->storageManager() : nullptr)
    23122249        manager->moveData(oldOrigin, newOrigin, [aggregator] { });
    2313 
    2314     if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && session && session->hasIDBDatabasePath())
    2315         session->ensureWebIDBServer().renameOrigin(oldOrigin, newOrigin, [aggregator] { });
    23162250}
    23172251
    … …  
    23732307        ASSERT(!isMainRunLoop());
    23742308
    2375         return CacheStorage::Engine::diskUsage(cacheRootPath, origin) + IDBServer::IDBServer::diskUsage(idbRootPath, origin);
     2309        auto cacheStoragePath = CacheStorage::Engine::storagePath(cacheRootPath, origin);
     2310        return CacheStorage::Engine::diskUsage(cacheStoragePath) + IDBServer::IDBServer::diskUsage(idbRootPath, origin);
    23762311    };
    23772312    StorageQuotaManager::QuotaIncreaseRequester quotaIncreaseRequester = [this, weakThis = WeakPtr { *this }, sessionID, origin] (uint64_t currentQuota, uint64_t currentSpace, uint64_t requestedIncrease, auto&& callback) {
    … …  
    25872522{
    25882523    if (auto* session = networkSession(sessionID)) {
    2589         if (auto* server = session->webIDBServer())
    2590             server->removeConnection(connection);
    25912524        if (auto* manager = session->storageManager())
    25922525            manager->stopReceivingMessageFromConnection(connection);

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.h

    r287371 r289474  
    3434#include "NetworkContentRuleListManager.h"
    3535#include "NetworkResourceLoadIdentifier.h"
     36#include "QuotaIncreaseRequestIdentifier.h"
    3637#include "RTCDataChannelRemoteManagerProxy.h"
    3738#include "SandboxExtension.h"
    … …  
    289290#endif
    290291
    291     bool shouldSuspendIDBServers() const { return m_shouldSuspendIDBServers; }
    292 
    293292    void syncLocalStorage(CompletionHandler<void()>&&);
    294293
    295294    void resetQuota(PAL::SessionID, CompletionHandler<void()>&&);
    296295    void clearStorage(PAL::SessionID, CompletionHandler<void()>&&);
     296    void didIncreaseQuota(PAL::SessionID, const WebCore::ClientOrigin&, QuotaIncreaseRequestIdentifier, std::optional<uint64_t> newQuota);
    297297    void renameOriginInWebsiteData(PAL::SessionID, const URL&, const URL&, OptionSet<WebsiteDataType>, CompletionHandler<void()>&&);
    298298
    … …  
    474474    void registerURLSchemeAsCORSEnabled(const String&) const;
    475475
    476     void suspendIDBServers(bool isSuspensionImminent);
    477 
    478476#if PLATFORM(IOS_FAMILY)
    479477    void setIsHoldingLockedFiles(bool);
    … …  
    483481        WTF_MAKE_FAST_ALLOCATED;
    484482    public:
     483        SessionStorageQuotaManager() = delete;
    485484        SessionStorageQuotaManager(const String& cacheRootPath, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota)
    486485            : m_cacheRootPath(cacheRootPath)
    … …  
    509508        String m_cacheRootPath;
    510509        String m_idbRootPath;
    511         uint64_t m_defaultQuota { WebCore::StorageQuotaManager::defaultQuota() };
    512         uint64_t m_defaultThirdPartyQuota { WebCore::StorageQuotaManager::defaultThirdPartyQuota() };
     510        uint64_t m_defaultQuota;
     511        uint64_t m_defaultThirdPartyQuota;
    513512        HashMap<WebCore::ClientOrigin, RefPtr<WebCore::StorageQuotaManager>> m_storageQuotaManagers;
    514513    };
    … …  
    550549    RefPtr<ProcessAssertion> m_holdingLockedFileAssertion;
    551550#endif
    552 
    553     bool m_shouldSuspendIDBServers { false };
    554     uint64_t m_suspensionIdentifier { 0 };
    555551   
    556552#if ENABLE(WEB_RTC)

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.messages.in

    r287371 r289474  
    180180    ResetQuota(PAL::SessionID sessionID) -> () Async
    181181    ClearStorage(PAL::SessionID sessionID) -> () Async
     182    DidIncreaseQuota(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, WebKit::QuotaIncreaseRequestIdentifier identifier, std::optional<uint64_t> newQuota)
    182183   
    183184#if ENABLE(APP_BOUND_DOMAINS)

  • trunk/Source/WebKit/NetworkProcess/NetworkSession.cpp

    r289247 r289474  
    206206        m_resourceLoadStatistics->invalidateAndCancel();
    207207#endif
    208     if (auto server = std::exchange(m_webIDBServer, nullptr))
    209         server->close();
    210208    if (auto manager = std::exchange(m_storageManager, nullptr))
    211209        manager->close();
    … …  
    662660}
    663661
    664 WebIDBServer& NetworkSession::ensureWebIDBServer()
    665 {
    666     if (!m_webIDBServer) {
    667         String path;
    668         if (!sessionID().isEphemeral()) {
    669             ASSERT(!m_idbDatabasePath.isNull());
    670             path = m_idbDatabasePath;
    671         }
    672 
    673         auto spaceRequester = [networkProcess = Ref { networkProcess() }, sessionID = sessionID()](const auto& origin, uint64_t spaceRequested) {
    674             return networkProcess->storageQuotaManager(sessionID, origin)->requestSpaceOnBackgroundThread(spaceRequested);
    675         };
    676 
    677         m_webIDBServer = WebIDBServer::create(sessionID(), path, WTFMove(spaceRequester));
    678         if (networkProcess().shouldSuspendIDBServers())
    679             m_webIDBServer->suspend(WebIDBServer::SuspensionCondition::Always);
    680     }
    681     return *m_webIDBServer;
    682 }
    683 
    684 void NetworkSession::closeIDBServer(CompletionHandler<void()>&& completionHandler)
    685 {
    686     if (!m_webIDBServer)
    687         return completionHandler();
    688 
    689     std::exchange(m_webIDBServer, nullptr)->close(WTFMove(completionHandler));
    690 }
    691 
    692 void NetworkSession::addIndexedDatabaseSession(const String& indexedDatabaseDirectory, SandboxExtension::Handle& handle)
    693 {
    694     // *********
    695     // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
    696     // *********
    697     auto isNew = m_idbDatabasePath.isNull();
    698     m_idbDatabasePath = indexedDatabaseDirectory;
    699     if (isNew) {
    700         SandboxExtension::consumePermanently(handle);
    701         networkProcess().setSessionStorageQuotaManagerIDBRootPath(sessionID(), indexedDatabaseDirectory);
    702     }
    703 }
    704 
    705 void NetworkSession::addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle)
     662void 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)
    706663{
    707664    if (m_storageManager)
    … …  
    710667    SandboxExtension::consumePermanently(generalStoragePathHandle);
    711668    SandboxExtension::consumePermanently(localStoragePathHandle);
    712     m_storageManager = NetworkStorageManager::create(sessionID(), generalStoragePath, localStoragePath);
     669    SandboxExtension::consumePermanently(idbStoragePathHandle);
     670    IPC::Connection::UniqueID connectionID;
     671    if (auto* connection = networkProcess().parentProcessConnection())
     672        connectionID = connection->uniqueID();
     673    m_storageManager = NetworkStorageManager::create(sessionID(), connectionID, generalStoragePath, localStoragePath, idbStoragePath, cacheStoragePath, defaultOriginQuota, defaultThirdPartyQuota);
    713674}
    714675

  • trunk/Source/WebKit/NetworkProcess/NetworkSession.h

    r289247 r289474  
    215215    WebSharedWorkerServer& ensureSharedWorkerServer();
    216216
    217     WebIDBServer* webIDBServer() { return m_webIDBServer.get(); }
    218     WebIDBServer& ensureWebIDBServer();
    219     void closeIDBServer(CompletionHandler<void()>&&);
    220     void addIndexedDatabaseSession(const String& indexedDatabaseDirectory, SandboxExtension::Handle&);
    221     bool hasIDBDatabasePath() const { return !m_idbDatabasePath.isEmpty(); }
    222 
    223217    NetworkStorageManager* storageManager() { return m_storageManager.get(); }
    224     void addStorageManagerSession(const String& generalStoragePath, SandboxExtension::Handle& generalStoragePathHandle, const String& localStoragePath, SandboxExtension::Handle& localStoragePathHandle);
     218    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);
    225219
    226220    CacheStorage::Engine* cacheEngine() { return m_cacheEngine.get(); }
    … …  
    325319    std::unique_ptr<WebSharedWorkerServer> m_sharedWorkerServer;
    326320
    327     String m_idbDatabasePath;
    328     RefPtr<WebIDBServer> m_webIDBServer;
    329 
    330321    RefPtr<NetworkStorageManager> m_storageManager;
    331322    RefPtr<CacheStorage::Engine> m_cacheEngine;

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp

    r289419 r289474  
    3232#include "NetworkProcess.h"
    3333#include "NetworkSession.h"
     34#include "NetworkStorageManager.h"
    3435#include "WebsiteDataType.h"
    3536#include <WebCore/CacheQueryOptions.h>
    … …  
    204205}
    205206
    206 uint64_t Engine::diskUsage(const String& rootPath, const WebCore::ClientOrigin& origin)
     207String Engine::storagePath(const String& rootDirectory, const WebCore::ClientOrigin& origin)
    207208{
    208209    ASSERT(!isMainRunLoop());
    209 
    210     if (rootPath.isEmpty())
    211         return 0;
    212 
    213     String saltPath = FileSystem::pathByAppendingComponent(rootPath, "salt"_s);
     210   
     211    if (rootDirectory.isEmpty())
     212        return emptyString();
     213
     214    String saltPath = FileSystem::pathByAppendingComponent(rootDirectory, "salt"_s);
    214215    auto salt = FileSystem::readOrMakeSalt(saltPath);
    215216    if (!salt)
     217        return emptyString();
     218
     219    Key key(origin.topOrigin.toString(), origin.clientOrigin.toString(), { }, { }, *salt);
     220    return FileSystem::pathByAppendingComponent(rootDirectory, key.hashAsString());
     221}
     222
     223uint64_t Engine::diskUsage(const String& originDirectory)
     224{
     225    ASSERT(!isMainRunLoop());
     226
     227    if (originDirectory.isEmpty())
    216228        return 0;
    217229
    218     Key key(origin.topOrigin.toString(), origin.clientOrigin.toString(), { }, { }, *salt);
    219     String directoryPath = FileSystem::pathByAppendingComponent(rootPath, key.hashAsString());
    220 
    221     String sizeFilePath = Caches::cachesSizeFilename(directoryPath);
     230    String sizeFilePath = Caches::cachesSizeFilename(originDirectory);
    222231    if (auto recordedSize = readSizeFile(sizeFilePath))
    223232        return *recordedSize;
    224233
    225     return getDirectorySize(directoryPath);
    226 }
    227 
    228 void Engine::requestSpace(const WebCore::ClientOrigin& origin, uint64_t spaceRequested, CompletionHandler<void(WebCore::StorageQuotaManager::Decision)>&& callback)
     234    return getDirectorySize(originDirectory);
     235}
     236
     237void Engine::requestSpace(const WebCore::ClientOrigin& origin, uint64_t spaceRequested, CompletionHandler<void(bool)>&& callback)
    229238{
    230239    ASSERT(isMainThread());
    231240
    232241    if (!m_networkProcess)
    233         callback(WebCore::StorageQuotaManager::Decision::Deny);
    234 
    235     RefPtr<WebCore::StorageQuotaManager> storageQuotaManager = m_networkProcess->storageQuotaManager(m_sessionID, origin);
    236     if (!storageQuotaManager)
    237         callback(WebCore::StorageQuotaManager::Decision::Deny);
    238 
    239     storageQuotaManager->requestSpaceOnMainThread(spaceRequested, WTFMove(callback));
     242        callback(false);
     243
     244    auto* session = m_networkProcess->networkSession(m_sessionID);
     245    if (!session)
     246        callback(false);
     247
     248    auto* storageManager = session->storageManager();
     249    if (!storageManager)
     250        callback(false);
     251
     252    storageManager->requestSpace(origin, spaceRequested, WTFMove(callback));
    240253}
    241254

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h

    r287229 r289474  
    3030#include "WebsiteData.h"
    3131#include <WebCore/ClientOrigin.h>
    32 #include <WebCore/StorageQuotaManager.h>
    3332#include <pal/SessionID.h>
    3433#include <wtf/HashMap.h>
    … …  
    8584    static void initializeQuotaUser(NetworkSession&, const WebCore::ClientOrigin&, CompletionHandler<void()>&&);
    8685
    87     static uint64_t diskUsage(const String& rootPath, const WebCore::ClientOrigin&);
    88     void requestSpace(const WebCore::ClientOrigin&, uint64_t spaceRequested, CompletionHandler<void(WebCore::StorageQuotaManager::Decision)>&&);
     86    static String storagePath(const String& rootDirectory, const WebCore::ClientOrigin&);
     87    static uint64_t diskUsage(const String& originDirectory);
     88    void requestSpace(const WebCore::ClientOrigin&, uint64_t spaceRequested, CompletionHandler<void(bool)>&&);
    8989
    9090    bool shouldPersist() const { return !!m_ioQueue;}

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp

    r288950 r289474  
    525525    }
    526526
    527     m_engine->requestSpace(m_origin, spaceRequired, [callback = WTFMove(callback)](auto decision) mutable {
    528         switch (decision) {
    529         case WebCore::StorageQuotaManager::Decision::Deny:
    530             callback(Error::QuotaExceeded);
    531             return;
    532         case WebCore::StorageQuotaManager::Decision::Grant:
    533             callback({ });
    534         };
     527    m_engine->requestSpace(m_origin, spaceRequired, [callback = WTFMove(callback)](bool granted) mutable {
     528        if (!granted)
     529            return callback(Error::QuotaExceeded);
     530        callback({ });
    535531    });
    536532}

  • trunk/Source/WebKit/NetworkProcess/ios/NetworkProcessIOS.mm

    r287159 r289474  
    110110    // while holding a locked file. We would get killed if suspended while holding locked files.
    111111    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     });
    125112}
    126113

  • trunk/Source/WebKit/NetworkProcess/storage/IDBStorageRegistry.h

    r289473 r289474  
    2727
    2828#include "Connection.h"
    29 #include <wtf/text/WTFString.h>
     29#include <WebCore/IDBResourceIdentifier.h>
     30#include <wtf/WeakPtr.h>
    3031
    3132namespace WebCore {
    32 struct ClientOrigin;
     33namespace IDBServer {
     34class UniqueIDBDatabaseConnection;
     35class UniqueIDBDatabaseTransaction;
     36}
    3337}
    3438
    3539namespace WebKit {
    3640
    37 class FileSystemStorageHandleRegistry;
    38 class FileSystemStorageManager;
    39 class LocalStorageManager;
    40 class SessionStorageManager;
    41 class StorageAreaRegistry;
    42 enum class WebsiteDataType : uint32_t;
     41class IDBStorageConnectionToClient;
    4342
    44 class OriginStorageManager {
     43class IDBStorageRegistry {
    4544    WTF_MAKE_FAST_ALLOCATED;
    4645public:
    47     OriginStorageManager(String&& path, String&& localStoragePath);
    48     ~OriginStorageManager();
    49 
    50     void connectionClosed(IPC::Connection::UniqueID);
    51     bool persisted() const { return m_persisted; }
    52     void setPersisted(bool value);
    53     FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry&);
    54     LocalStorageManager& localStorageManager(StorageAreaRegistry&);
    55     LocalStorageManager* existingLocalStorageManager();
    56     SessionStorageManager& sessionStorageManager(StorageAreaRegistry&);
    57     SessionStorageManager* existingSessionStorageManager();
    58     bool isActive();
    59     bool isEmpty();
    60     OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType>);
    61     void deleteData(OptionSet<WebsiteDataType>, WallTime);
    62     void moveData(const String& newPath, const String& localStoragePath);
     46    IDBStorageRegistry();
     47    WebCore::IDBServer::IDBConnectionToClient& ensureConnectionToClient(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* connection(uint64_t identifier);
     52    void registerTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&);
     53    void unregisterTransaction(WebCore::IDBServer::UniqueIDBDatabaseTransaction&);
     54    WebCore::IDBServer::UniqueIDBDatabaseTransaction* transaction(WebCore::IDBResourceIdentifier);
    6355
    6456private:
    65     enum class StorageBucketMode : bool;
    66     class StorageBucket;
    67     StorageBucket& defaultBucket();
    68 
    69     void createOriginFileIfNecessary(const WebCore::ClientOrigin&);
    70     void deleteOriginFileIfNecessary();
    71 
    72     std::unique_ptr<StorageBucket> m_defaultBucket;
    73     String m_path;
    74     bool m_persisted { false };
    75     String m_localStoragePath;
     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;
    7660};
    7761
    7862} // namespace WebKit
    79 

  • trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp

    r289081 r289474  
    2727#include "NetworkStorageManager.h"
    2828
     29#include "CacheStorageEngine.h"
    2930#include "FileSystemStorageHandleRegistry.h"
    3031#include "FileSystemStorageManager.h"
     32#include "IDBStorageConnectionToClient.h"
     33#include "IDBStorageManager.h"
     34#include "IDBStorageRegistry.h"
    3135#include "LocalStorageManager.h"
    3236#include "Logging.h"
     37#include "NetworkProcessProxyMessages.h"
    3338#include "NetworkStorageManagerMessages.h"
    3439#include "OriginStorageManager.h"
     40#include "QuotaManager.h"
    3541#include "SessionStorageManager.h"
    3642#include "StorageAreaBase.h"
    … …  
    3945#include "WebsiteDataType.h"
    4046#include <WebCore/SecurityOriginData.h>
     47#include <WebCore/UniqueIDBDatabaseConnection.h>
     48#include <WebCore/UniqueIDBDatabaseTransaction.h>
    4149#include <pal/crypto/CryptoDigest.h>
    4250#include <wtf/Scope.h>
    … …  
    101109}
    102110
    103 Ref<NetworkStorageManager> NetworkStorageManager::create(PAL::SessionID sessionID, const String& path, const String& customLocalStoragePath)
    104 {
    105     return adoptRef(*new NetworkStorageManager(sessionID, path, customLocalStoragePath));
    106 }
    107 
    108 NetworkStorageManager::NetworkStorageManager(PAL::SessionID sessionID, const String& path, const String& customLocalStoragePath)
     111Ref<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)
     112{
     113    return adoptRef(*new NetworkStorageManager(sessionID, connection, path, customLocalStoragePath, customIDBStoragePath, customCacheStoragePath, defaultOriginQuota, defaultThirdPartyOriginQuota));
     114}
     115
     116NetworkStorageManager::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)
    109117    : m_sessionID(sessionID)
    110118    , m_queue(SuspendableWorkQueue::create("com.apple.WebKit.Storage"))
    111 {
    112     ASSERT(RunLoop::isMain());
    113 
    114     m_queue->dispatch([this, protectedThis = Ref { *this }, path = path.isolatedCopy(), customLocalStoragePath = crossThreadCopy(customLocalStoragePath)]() mutable {
     119    , m_defaultOriginQuota(defaultOriginQuota)
     120    , m_defaultThirdPartyOriginQuota(defaultThirdPartyOriginQuota)
     121    , m_parentConnection(connection)
     122{
     123    ASSERT(RunLoop::isMain());
     124
     125    m_queue->dispatch([this, protectedThis = Ref { *this }, path = path.isolatedCopy(), customLocalStoragePath = crossThreadCopy(customLocalStoragePath), customIDBStoragePath = crossThreadCopy(customIDBStoragePath), customCacheStoragePath = crossThreadCopy(customCacheStoragePath)]() mutable {
    115126        m_fileSystemStorageHandleRegistry = makeUnique<FileSystemStorageHandleRegistry>();
    116127        m_storageAreaRegistry = makeUnique<StorageAreaRegistry>();
     128        m_idbStorageRegistry = makeUnique<IDBStorageRegistry>();
    117129        m_path = path;
    118130        m_customLocalStoragePath = customLocalStoragePath;
     131        m_customIDBStoragePath = customIDBStoragePath;
     132        m_customCacheStoragePath = customCacheStoragePath;
    119133        if (!m_path.isEmpty()) {
    120134            auto saltPath = FileSystem::pathByAppendingComponent(m_path, "salt");
    … …  
    132146bool NetworkStorageManager::canHandleTypes(OptionSet<WebsiteDataType> types)
    133147{
    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);
    135152}
    136153
    … …  
    171188    connection.removeWorkQueueMessageReceiver(Messages::NetworkStorageManager::messageReceiverName());
    172189    m_queue->dispatch([this, protectedThis = Ref { *this }, connection = connection.uniqueID()]() mutable {
     190        m_idbStorageRegistry->removeConnectionToClient(connection);
    173191        m_localOriginStorageManagers.removeIf([&](auto& entry) {
    174192            auto& manager = entry.value;
    … …  
    223241            });
    224242        }
    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));
    226251    }).iterator->value;
    227252}
    … …  
    280305            completionHandler();
    281306        });
     307    });
     308}
     309
     310void 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);
    282317    });
    283318}
    … …  
    453488        allOrigins.add(WebCore::ClientOrigin { origin, origin });
    454489
     490    for (auto& origin : IDBStorageManager::originsOfIDBStorageData(m_customIDBStoragePath))
     491        allOrigins.add(origin);
     492
    455493    return allOrigins;
    456494}
    … …  
    580618       
    581619        // Clear existing data of target origin.
    582         OptionSet<WebsiteDataType> types = { WebsiteDataType::FileSystem, WebsiteDataType::LocalStorage, WebsiteDataType::SessionStorage  };
     620        OptionSet<WebsiteDataType> types = {
     621            WebsiteDataType::FileSystem,
     622            WebsiteDataType::LocalStorage,
     623            WebsiteDataType::SessionStorage,
     624            WebsiteDataType::IndexedDBDatabases
     625        };
    583626        localOriginStorageManager(targetOrigin).deleteData(types, -WallTime::infinity());
    584627        removeOriginStorageManagerIfPossible(targetOrigin);
    585628
    586629        // Move data from source origin to target origin.
    587         localOriginStorageManager(sourceOrigin).moveData(originDirectoryPath(m_path, targetOrigin, m_salt), LocalStorageManager::localStorageFilePath(m_customLocalStoragePath, targetOrigin));
     630        localOriginStorageManager(sourceOrigin).moveData(originDirectoryPath(m_path, targetOrigin, m_salt), LocalStorageManager::localStorageFilePath(m_customLocalStoragePath, targetOrigin), IDBStorageManager::idbStorageOriginDirectory(m_customIDBStoragePath, targetOrigin));
    588631        removeOriginStorageManagerIfPossible(sourceOrigin);
    589632
    … …  
    600643            if (auto localStorageManager = manager->existingLocalStorageManager())
    601644                localStorageManager->syncLocalStorage();
     645            if (auto idbStorageManager = manager->existingIDBStorageManager())
     646                idbStorageManager->stopDatabaseActivitiesForSuspend();
    602647        }
    603648    }, WTFMove(completionHandler));
    … …  
    634679
    635680        RunLoop::main().dispatch(WTFMove(completionHandler));
     681    });
     682}
     683
     684void NetworkStorageManager::registerTemporaryBlobFilePaths(IPC::Connection& connection, const Vector<String>& filePaths)
     685{
     686    ASSERT(RunLoop::isMain());
     687
     688    m_queue->dispatch([this, protectedThis = Ref { *this }, connectionID = connection.uniqueID(), filePaths = crossThreadCopy(filePaths)] {
     689        auto& temporaryBlobPaths = m_temporaryBlobPathsByConnection.ensure(connectionID, [] {
     690            return HashSet<String> { };
     691        }).iterator->value;
     692        temporaryBlobPaths.add(filePaths.begin(), filePaths.end());
     693    });
     694}
     695
     696void NetworkStorageManager::requestSpace(const WebCore::ClientOrigin& origin, uint64_t size, CompletionHandler<void(bool)>&& completionHandler)
     697{
     698    ASSERT(RunLoop::isMain());
     699
     700    m_queue->dispatch([this, protectedThis = Ref { *this }, origin = crossThreadCopy(origin), size, completionHandler = WTFMove(completionHandler)]() mutable {
     701        localOriginStorageManager(origin).quotaManager().requestSpace(size, [completionHandler = WTFMove(completionHandler)](auto decision) mutable {
     702            RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), decision]() mutable {
     703                completionHandler(decision == QuotaManager::Decision::Grant);
     704            });
     705        });
     706    });
     707}
     708
     709void NetworkStorageManager::resetQuotaForTesting(CompletionHandler<void()>&& completionHandler)
     710{
     711    ASSERT(RunLoop::isMain());
     712
     713    m_queue->dispatch([this, protectedThis = Ref { *this }, completionHandler = WTFMove(completionHandler)]() mutable {
     714        for (auto& manager : m_localOriginStorageManagers.values())
     715            manager->quotaManager().resetQuotaForTesting();
     716        RunLoop::main().dispatch(WTFMove(completionHandler));
     717    });
     718}
     719
     720void NetworkStorageManager::resetQuotaUpdatedBasedOnUsageForTesting(const WebCore::ClientOrigin& origin)
     721{
     722    ASSERT(RunLoop::isMain());
     723
     724    m_queue->dispatch([this, protectedThis = Ref { *this }, origin = crossThreadCopy(origin)]() mutable {
     725        if (auto manager = m_localOriginStorageManagers.get(origin))
     726            manager->quotaManager().resetQuotaUpdatedBasedOnUsageForTesting();
    636727    });
    637728}
    … …  
    724815}
    725816
     817void NetworkStorageManager::openDatabase(IPC::Connection& connection, const WebCore::IDBRequestData& requestData)
     818{
     819    auto& connectionToClient = m_idbStorageRegistry->ensureConnectionToClient(connection.uniqueID(), requestData.requestIdentifier().connectionIdentifier());
     820    localOriginStorageManager(requestData.databaseIdentifier().origin()).idbStorageManager(*m_idbStorageRegistry).openDatabase(connectionToClient, requestData);
     821}
     822
     823void NetworkStorageManager::openDBRequestCancelled(const WebCore::IDBRequestData& requestData)
     824{
     825    localOriginStorageManager(requestData.databaseIdentifier().origin()).idbStorageManager(*m_idbStorageRegistry).openDBRequestCancelled(requestData);
     826}
     827
     828void NetworkStorageManager::deleteDatabase(IPC::Connection& connection, const WebCore::IDBRequestData& requestData)
     829{
     830    auto& connectionToClient = m_idbStorageRegistry->ensureConnectionToClient(connection.uniqueID(), requestData.requestIdentifier().connectionIdentifier());
     831    localOriginStorageManager(requestData.databaseIdentifier().origin()).idbStorageManager(*m_idbStorageRegistry).deleteDatabase(connectionToClient, requestData);
     832}
     833
     834void NetworkStorageManager::establishTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBTransactionInfo& transactionInfo)
     835{
     836    if (auto connection = m_idbStorageRegistry->connection(databaseConnectionIdentifier))
     837        connection->establishTransaction(transactionInfo);
     838}
     839
     840void NetworkStorageManager::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
     841{
     842    if (auto connection = m_idbStorageRegistry->connection(databaseConnectionIdentifier))
     843        connection->connectionPendingCloseFromClient();
     844}
     845
     846void NetworkStorageManager::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
     847{
     848    if (auto connection = m_idbStorageRegistry->connection(databaseConnectionIdentifier))
     849        connection->connectionClosedFromClient();
     850}
     851
     852void NetworkStorageManager::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier)
     853{
     854    if (auto transaction = m_idbStorageRegistry->transaction(transactionIdentifier))
     855        transaction->abortWithoutCallback();
     856
     857    if (auto connection = m_idbStorageRegistry->connection(databaseConnectionIdentifier))
     858        connection->connectionClosedFromClient();
     859}
     860
     861void NetworkStorageManager::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier, const WebCore::IndexedDB::ConnectionClosedOnBehalfOfServer connectionClosed)
     862{
     863    if (auto connection = m_idbStorageRegistry->connection(databaseConnectionIdentifier))
     864        connection->didFireVersionChangeEvent(requestIdentifier, connectionClosed);
     865}
     866
     867void NetworkStorageManager::abortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier)
     868{
     869    if (auto transaction = m_idbStorageRegistry->transaction(transactionIdentifier))
     870        transaction->abort();
     871}
     872
     873void NetworkStorageManager::commitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, uint64_t pendingRequestCount)
     874{
     875    if (auto transaction = m_idbStorageRegistry->transaction(transactionIdentifier))
     876        transaction->commit(pendingRequestCount);
     877}
     878
     879void NetworkStorageManager::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier)
     880{
     881    if (auto connection = m_idbStorageRegistry->connection(databaseConnectionIdentifier))
     882        connection->didFinishHandlingVersionChange(transactionIdentifier);
     883}
     884
     885void NetworkStorageManager::createObjectStore(const WebCore::IDBRequestData& requestData, const WebCore::IDBObjectStoreInfo& objectStoreInfo)
     886{
     887    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier())) {
     888        ASSERT(transaction->isVersionChange());
     889        transaction->createObjectStore(requestData, objectStoreInfo);
     890    }
     891}
     892
     893void NetworkStorageManager::deleteObjectStore(const WebCore::IDBRequestData& requestData, const String& objectStoreName)
     894{
     895    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier())) {
     896        ASSERT(transaction->isVersionChange());
     897        transaction->deleteObjectStore(requestData, objectStoreName);
     898    }
     899}
     900
     901void NetworkStorageManager::renameObjectStore(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& newName)
     902{
     903    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier())) {
     904        ASSERT(transaction->isVersionChange());
     905        transaction->renameObjectStore(requestData, objectStoreIdentifier, newName);
     906    }
     907}
     908
     909void NetworkStorageManager::clearObjectStore(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier)
     910{
     911    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     912        transaction->clearObjectStore(requestData, objectStoreIdentifier);
     913}
     914
     915void NetworkStorageManager::createIndex(const WebCore::IDBRequestData& requestData, const WebCore::IDBIndexInfo& indexInfo)
     916{
     917    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     918        transaction->createIndex(requestData, indexInfo);
     919}
     920
     921void NetworkStorageManager::deleteIndex(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
     922{
     923    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     924        transaction->deleteIndex(requestData, objectStoreIdentifier, indexName);
     925}
     926
     927void NetworkStorageManager::renameIndex(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
     928{
     929    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     930        transaction->renameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName);
     931}
     932
     933void NetworkStorageManager::putOrAdd(IPC::Connection& connection, const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyData& keyData, const WebCore::IDBValue& value, WebCore::IndexedDB::ObjectStoreOverwriteMode overwriteMode)
     934{
     935    if (value.blobURLs().size() != value.blobFilePaths().size()) {
     936        RELEASE_LOG_FAULT(IndexedDB, "NetworkStorageManager::putOrAdd: Number of blob URLs doesn't match the number of blob file paths.");
     937        ASSERT_NOT_REACHED();
     938        return;
     939    }
     940
     941    // Validate temporary blob paths in |value| to make sure they belong to the source process.
     942    if (!value.blobFilePaths().isEmpty()) {
     943        auto it = m_temporaryBlobPathsByConnection.find(connection.uniqueID());
     944        if (it == m_temporaryBlobPathsByConnection.end()) {
     945            RELEASE_LOG_FAULT(IndexedDB, "NetworkStorageManager::putOrAdd: IDBValue contains blob paths but none are allowed for this process");
     946            ASSERT_NOT_REACHED();
     947            return;
     948        }
     949
     950        auto& temporaryBlobPathsForConnection = it->value;
     951        for (auto& blobFilePath : value.blobFilePaths()) {
     952            if (!temporaryBlobPathsForConnection.remove(blobFilePath)) {
     953                RELEASE_LOG_FAULT(IndexedDB, "NetworkStorageManager::putOrAdd: Blob path was not created for this WebProcess");
     954                ASSERT_NOT_REACHED();
     955                return;
     956            }
     957        }
     958    }
     959
     960    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     961        transaction->putOrAdd(requestData, keyData, value, overwriteMode);
     962}
     963
     964void NetworkStorageManager::getRecord(const WebCore::IDBRequestData& requestData, const WebCore::IDBGetRecordData& getRecordData)
     965{
     966    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     967        transaction->getRecord(requestData, getRecordData);
     968}
     969
     970void NetworkStorageManager::getAllRecords(const WebCore::IDBRequestData& requestData, const WebCore::IDBGetAllRecordsData& getAllRecordsData)
     971{
     972    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     973        transaction->getAllRecords(requestData, getAllRecordsData);
     974}
     975
     976void NetworkStorageManager::getCount(const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyRangeData& keyRangeData)
     977{
     978    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     979        transaction->getCount(requestData, keyRangeData);
     980}
     981
     982void NetworkStorageManager::deleteRecord(const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyRangeData& keyRangeData)
     983{
     984    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     985        transaction->deleteRecord(requestData, keyRangeData);
     986}
     987
     988void NetworkStorageManager::openCursor(const WebCore::IDBRequestData& requestData, const WebCore::IDBCursorInfo& cursorInfo)
     989{
     990    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     991        transaction->openCursor(requestData, cursorInfo);
     992}
     993
     994void NetworkStorageManager::iterateCursor(const WebCore::IDBRequestData& requestData, const WebCore::IDBIterateCursorData& cursorData)
     995{
     996    if (auto transaction = m_idbStorageRegistry->transaction(requestData.transactionIdentifier()))
     997        transaction->iterateCursor(requestData, cursorData);
     998}
     999
     1000void NetworkStorageManager::getAllDatabaseNamesAndVersions(IPC::Connection& connection, const WebCore::IDBResourceIdentifier& requestIdentifier, const WebCore::ClientOrigin& origin)
     1001{
     1002    auto& connectionToClient = m_idbStorageRegistry->ensureConnectionToClient(connection.uniqueID(), requestIdentifier.connectionIdentifier());
     1003    auto result = localOriginStorageManager(origin).idbStorageManager(*m_idbStorageRegistry).getAllDatabaseNamesAndVersions();
     1004    connectionToClient.didGetAllDatabaseNamesAndVersions(requestIdentifier, WTFMove(result));
     1005}
     1006
    7261007} // namespace WebKit
    7271008

  • trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h

    r288551 r289474  
    3737#include <WebCore/FileSystemHandleIdentifier.h>
    3838#include <WebCore/FileSystemSyncAccessHandleIdentifier.h>
     39#include <WebCore/IDBResourceIdentifier.h>
     40#include <WebCore/IndexedDB.h>
    3941#include <pal/SessionID.h>
    4042#include <wtf/Forward.h>
    … …  
    4547
    4648namespace WebCore {
     49class IDBCursorInfo;
     50class IDBKeyData;
     51class IDBIndexInfo;
     52class IDBObjectStoreInfo;
     53class IDBRequestData;
     54class IDBTransactionInfo;
     55class IDBValue;
    4756struct ClientOrigin;
     57struct IDBGetAllRecordsData;
     58struct IDBGetRecordData;
     59struct IDBGetAllRecordsData;
     60struct IDBIterateCursorData;
     61struct IDBKeyRangeData;
    4862enum class StorageType : uint8_t;
    4963}
    … …  
    5266
    5367class FileSystemStorageHandleRegistry;
     68class IDBStorageRegistry;
    5469class StorageAreaRegistry;
    5570
    5671class NetworkStorageManager final : public IPC::Connection::WorkQueueMessageReceiver {
    5772public:
    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);
    5974    static bool canHandleTypes(OptionSet<WebsiteDataType>);
    6075
    … …  
    6580    void close();
    6681    void clearStorageForTesting(CompletionHandler<void()>&&);
     82    void didIncreaseQuota(const WebCore::ClientOrigin&, QuotaIncreaseRequestIdentifier, std::optional<uint64_t> newQuota);
    6783    void fetchData(OptionSet<WebsiteDataType>, CompletionHandler<void(Vector<WebsiteData::Entry>&&)>&&);
    6884    void deleteData(OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, CompletionHandler<void()>&&);
    … …  
    7490    void handleLowMemoryWarning();
    7591    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&);
    7696
    7797private:
    7898    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);
    79100    ~NetworkStorageManager();
    80101    OriginStorageManager& localOriginStorageManager(const WebCore::ClientOrigin&);
    81102    bool removeOriginStorageManagerIfPossible(const WebCore::ClientOrigin&);
    82103    void deleteOriginDirectoryIfPossible(const WebCore::ClientOrigin&);
    83     FileSystemStorageHandleRegistry& fileSystemStorageHandleRegistry();
    84104
    85105    void forEachOriginDirectory(const Function<void(const String&)>&);
    … …  
    119139    void clear(IPC::Connection&, StorageAreaIdentifier, StorageAreaImplIdentifier, String&& urlString, CompletionHandler<void()>&&);
    120140
     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
    121169    PAL::SessionID m_sessionID;
    122170    Ref<SuspendableWorkQueue> m_queue;
    … …  
    128176    std::unique_ptr<FileSystemStorageHandleRegistry> m_fileSystemStorageHandleRegistry;
    129177    std::unique_ptr<StorageAreaRegistry> m_storageAreaRegistry;
     178    std::unique_ptr<IDBStorageRegistry> m_idbStorageRegistry;
    130179    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;
    131186};
    132187

  • trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.messages.in

    r288551 r289474  
    4848    RemoveItem(WebKit::StorageAreaIdentifier identifier, WebKit::StorageAreaImplIdentifier implIdentifier, String key, String urlString) -> () Async WantsConnection
    4949    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
    5077}

  • trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp

    r289200 r289474  
    2727#include "OriginStorageManager.h"
    2828
     29#include "CacheStorageEngine.h"
    2930#include "FileSystemStorageHandleRegistry.h"
    3031#include "FileSystemStorageManager.h"
     32#include "IDBStorageManager.h"
     33#include "IDBStorageRegistry.h"
    3134#include "LocalStorageManager.h"
    3235#include "MemoryStorageArea.h"
    … …  
    4548    WTF_MAKE_FAST_ALLOCATED;
    4649public:
    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)
    4851        : m_rootPath(rootPath)
    4952        , m_identifier(identifier)
    5053        , m_localStoragePath(localStoragePath)
     54        , m_idbStoragePath(idbStoragePath)
    5155    {
    5256    }
    … …  
    7175        LocalStorage,
    7276        SessionStorage,
     77        IndexedDB,
    7378    };
    7479
    … …  
    8186        if (storageIdentifier == "SessionStorage"_s)
    8287            return WebsiteDataType::SessionStorage;
     88        if (storageIdentifier == "IndexedDB"_s)
     89            return WebsiteDataType::IndexedDBDatabases;
    8390
    8491        return std::nullopt;
    … …  
    94101        case StorageType::SessionStorage:
    95102            return "SessionStorage"_s;
     103        case StorageType::IndexedDB:
     104            return "IndexedDB"_s;
    96105        default:
    97106            break;
    … …  
    142151    {
    143152        return m_sessionStorageManager.get();
     153    }
     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();
    144166    }
    145167
    … …  
    150172        return (m_fileSystemStorageManager && m_fileSystemStorageManager->isActive())
    151173            || (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()));
    153176    }
    154177
    … …  
    166189            return false;
    167190
    168         return !FileSystem::fileExists(m_localStoragePath);
     191        FileSystem::deleteEmptyDirectory(m_idbStoragePath);
     192        return !FileSystem::fileExists(m_localStoragePath) && !FileSystem::fileExists(m_idbStoragePath);
    169193    }
    170194
    … …  
    187211        if (types.contains(WebsiteDataType::SessionStorage) && modifiedSinceTime < WallTime::now())
    188212            deleteSessionStorageData();
    189     }
    190 
    191     void moveData(const String& path, const String& localStoragePath)
     213
     214        if (types.contains(WebsiteDataType::IndexedDBDatabases))
     215            deleteIDBStorageData(modifiedSinceTime);
     216    }
     217
     218    void moveData(const String& path, const String& localStoragePath, const String& idbStoragePath)
    192219    {
    193220        m_fileSystemStorageManager = nullptr;
    … …  
    195222            m_localStorageManager->close();
    196223
     224        if (m_idbStorageManager)
     225            m_idbStorageManager->closeDatabasesForDeletion();
     226
    197227        FileSystem::makeAllDirectories(FileSystem::parentPath(path));
    198228        FileSystem::moveFile(m_rootPath, path);
    … …  
    201231            FileSystem::makeAllDirectories(FileSystem::parentPath(localStoragePath));
    202232            WebCore::SQLiteFileSystem::moveDatabaseFile(m_localStoragePath, localStoragePath);
     233        }
     234
     235        if (!m_idbStoragePath.isEmpty() && !idbStoragePath.isEmpty()) {
     236            FileSystem::makeAllDirectories(FileSystem::parentPath(idbStoragePath));
     237            WebCore::SQLiteFileSystem::moveDatabaseFile(m_idbStoragePath, idbStoragePath);
    203238        }
    204239    }
    … …  
    218253        }
    219254
     255        if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
     256            if (m_idbStorageManager && m_idbStorageManager->hasDataInMemory())
     257                result.add(WebsiteDataType::IndexedDBDatabases);
     258        }
     259
    220260        return result;
    221261    }
    … …  
    234274        }
    235275
     276        if (types.contains(WebsiteDataType::IndexedDBDatabases) && !result.contains(WebsiteDataType::IndexedDBDatabases)) {
     277            if (auto databases = FileSystem::listDirectory(m_idbStoragePath); !databases.isEmpty())
     278                result.add(WebsiteDataType::IndexedDBDatabases);
     279        }
     280
    236281        return result;
    237282    }
    … …  
    269314        if (!m_sessionStorageManager->isActive())
    270315            m_sessionStorageManager = nullptr;
     316    }
     317   
     318    void deleteIDBStorageData(WallTime time)
     319    {
     320        if (m_idbStorageManager)
     321            m_idbStorageManager->closeDatabasesForDeletion();
     322
     323        FileSystem::deleteAllFilesModifiedSince(m_idbStoragePath, time);
    271324    }
    272325   
    … …  
    278331    String m_localStoragePath;
    279332    std::unique_ptr<SessionStorageManager> m_sessionStorageManager;
     333    std::unique_ptr<IDBStorageManager> m_idbStorageManager;
     334    String m_idbStoragePath;
    280335};
    281336
    282 OriginStorageManager::OriginStorageManager(String&& path, String&& localStoragePath)
     337static Ref<QuotaManager> createQuotaManager(uint64_t quota, const String& idbStoragePath, const String& cacheStoragePath, QuotaManager::IncreaseQuotaFunction&& increaseQuotaFunction)
     338{
     339    QuotaManager::GetUsageFunction getUsageFunction = [idbStoragePath, cacheStoragePath]() {
     340        return IDBStorageManager::idbStorageSize(idbStoragePath) + CacheStorage::Engine::diskUsage(cacheStoragePath);
     341    };
     342    return QuotaManager::create(quota, WTFMove(getUsageFunction), WTFMove(increaseQuotaFunction));
     343}
     344
     345OriginStorageManager::OriginStorageManager(uint64_t quota, QuotaManager::IncreaseQuotaFunction&& increaseQuotaFunction, String&& path, String&& localStoragePath, String&& idbStoragePath, String&& cacheStoragePath)
    283346    : m_path(WTFMove(path))
    284347    , m_localStoragePath(WTFMove(localStoragePath))
     348    , m_idbStoragePath(WTFMove(idbStoragePath))
     349    , m_cacheStoragePath(WTFMove(cacheStoragePath))
     350    , m_quotaManager(createQuotaManager(quota, m_idbStoragePath, m_cacheStoragePath, WTFMove(increaseQuotaFunction)))
    285351{
    286352    ASSERT(!RunLoop::isMain());
    … …  
    298364{
    299365    if (!m_defaultBucket)
    300         m_defaultBucket = makeUnique<StorageBucket>(m_path, "default"_s, m_localStoragePath);
     366        m_defaultBucket = makeUnique<StorageBucket>(m_path, "default"_s, m_localStoragePath, m_idbStoragePath);
    301367
    302368    return *m_defaultBucket;
    303369}
    304370
     371QuotaManager& OriginStorageManager::quotaManager()
     372{
     373    return m_quotaManager.get();
     374}
     375
    305376FileSystemStorageManager& OriginStorageManager::fileSystemStorageManager(FileSystemStorageHandleRegistry& registry)
    306377{
    … …  
    326397{
    327398    return defaultBucket().existingSessionStorageManager();
     399}
     400
     401IDBStorageManager& OriginStorageManager::idbStorageManager(IDBStorageRegistry& registry)
     402{
     403    return defaultBucket().idbStorageManager(registry, [quotaManager = WeakPtr { this->quotaManager() }](uint64_t spaceRequested, CompletionHandler<void(bool)>&& completionHandler) mutable {
     404        if (!quotaManager)
     405            return completionHandler(false);
     406
     407        quotaManager->requestSpace(spaceRequested, [completionHandler = WTFMove(completionHandler)](auto decision) mutable {
     408            completionHandler(decision == QuotaManager::Decision::Grant);
     409        });
     410    });
     411}
     412
     413IDBStorageManager* OriginStorageManager::existingIDBStorageManager()
     414{
     415    return defaultBucket().existingIDBStorageManager();
    328416}
    329417
    … …  
    360448}
    361449
    362 void OriginStorageManager::moveData(const String& newPath, const String& localStoragePath)
     450void OriginStorageManager::moveData(const String& newPath, const String& localStoragePath, const String& idbStoragePath)
    363451{
    364452    ASSERT(!RunLoop::isMain());
    365453
    366     defaultBucket().moveData(newPath, localStoragePath);
     454    defaultBucket().moveData(newPath, localStoragePath, idbStoragePath);
    367455}
    368456

  • trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.h

    r289081 r289474  
    2727
    2828#include "Connection.h"
     29#include "QuotaManager.h"
    2930#include <wtf/text/WTFString.h>
    30 
    31 namespace WebCore {
    32 struct ClientOrigin;
    33 }
    3431
    3532namespace WebKit {
    … …  
    3734class FileSystemStorageHandleRegistry;
    3835class FileSystemStorageManager;
     36class IDBStorageManager;
     37class IDBStorageRegistry;
    3938class LocalStorageManager;
    4039class SessionStorageManager;
    … …  
    4544    WTF_MAKE_FAST_ALLOCATED;
    4645public:
    47     OriginStorageManager(String&& path, String&& localStoragePath);
     46    OriginStorageManager(uint64_t quota, QuotaManager::IncreaseQuotaFunction&&, String&& path, String&& localStoragePath, String&& idbStoragePath, String&& cacheStoragePath);
    4847    ~OriginStorageManager();
    4948
    … …  
    5150    bool persisted() const { return m_persisted; }
    5251    void setPersisted(bool value);
     52    QuotaManager& quotaManager();
    5353    FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry&);
    5454    LocalStorageManager& localStorageManager(StorageAreaRegistry&);
    … …  
    5656    SessionStorageManager& sessionStorageManager(StorageAreaRegistry&);
    5757    SessionStorageManager* existingSessionStorageManager();
     58    IDBStorageManager& idbStorageManager(IDBStorageRegistry&);
     59    IDBStorageManager* existingIDBStorageManager();
    5860    bool isActive();
    5961    bool isEmpty();
    6062    OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType>);
    6163    void deleteData(OptionSet<WebsiteDataType>, WallTime);
    62     void moveData(const String& newPath, const String& localStoragePath);
     64    void moveData(const String& newPath, const String& localStoragePath, const String& idbStoragePath);
    6365
    6466private:
    … …  
    6769    StorageBucket& defaultBucket();
    6870
    69     void createOriginFileIfNecessary(const WebCore::ClientOrigin&);
    70     void deleteOriginFileIfNecessary();
    71 
    7271    std::unique_ptr<StorageBucket> m_defaultBucket;
    7372    String m_path;
    7473    bool m_persisted { false };
    7574    String m_localStoragePath;
     75    String m_idbStoragePath;
     76    String m_cacheStoragePath;
     77    Ref<QuotaManager> m_quotaManager;
    7678};
    7779

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r289247 r289474  
    289289        'WebCore::PageIdentifier',
    290290        'WebCore::PlaybackTargetClientContextIdentifier',
     291        'WebKit::QuotaIncreaseRequestIdentifier',
    291292        'WebCore::PluginLoadClientPolicy',
    292293        'WebCore::PointerID',

  • trunk/Source/WebKit/Shared/WebsiteDataStoreParameters.h

    r282130 r289474  
    7272    SandboxExtension::Handle generalStorageDirectoryHandle;
    7373
    74     uint64_t perOriginStorageQuota { WebCore::StorageQuotaManager::defaultQuota() };
    75     uint64_t perThirdPartyOriginStorageQuota { WebCore::StorageQuotaManager::defaultThirdPartyQuota() };
     74    uint64_t perOriginStorageQuota;
     75    uint64_t perThirdPartyOriginStorageQuota;
    7676};
    7777

  • trunk/Source/WebKit/Sources.txt

    r289247 r289474  
    150150NetworkProcess/storage/FileSystemStorageHandle.cpp
    151151NetworkProcess/storage/FileSystemStorageHandleRegistry.cpp
     152NetworkProcess/storage/IDBStorageConnectionToClient.cpp
     153NetworkProcess/storage/IDBStorageManager.cpp
     154NetworkProcess/storage/IDBStorageRegistry.cpp
    152155NetworkProcess/storage/LocalStorageManager.cpp
    153156NetworkProcess/storage/MemoryStorageArea.cpp
    154157NetworkProcess/storage/NetworkStorageManager.cpp
    155158NetworkProcess/storage/OriginStorageManager.cpp
     159NetworkProcess/storage/QuotaManager.cpp
    156160NetworkProcess/storage/SQLiteStorageArea.cpp
    157161NetworkProcess/storage/SessionStorageManager.cpp

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

    r289247 r289474  
    15071507}
    15081508
     1509void NetworkProcessProxy::increaseQuota(PAL::SessionID sessionID, const WebCore::ClientOrigin& origin, QuotaIncreaseRequestIdentifier identifier, uint64_t currentQuota, uint64_t currentUsage, uint64_t spaceRequested)
     1510{
     1511    requestStorageSpace(sessionID, origin, currentQuota, currentUsage, spaceRequested, [this, weakThis = WeakPtr { *this }, sessionID, origin, identifier](auto result) mutable {
     1512        if (!weakThis)
     1513            return;
     1514
     1515        send(Messages::NetworkProcess::DidIncreaseQuota(sessionID, origin, identifier, result), 0);
     1516    });
     1517}
     1518
    15091519void NetworkProcessProxy::registerSchemeForLegacyCustomProtocol(const String& scheme)
    15101520{

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h

    r289247 r289474  
    3434#include "ProcessThrottler.h"
    3535#include "ProcessThrottlerClient.h"
     36#include "QuotaIncreaseRequestIdentifier.h"
    3637#include "UserContentControllerIdentifier.h"
    3738#include "WebProcessProxyMessagesReplies.h"
    … …  
    343344
    344345    void requestStorageSpace(PAL::SessionID, const WebCore::ClientOrigin&, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(std::optional<uint64_t> quota)>&&);
     346    void increaseQuota(PAL::SessionID, const WebCore::ClientOrigin&, QuotaIncreaseRequestIdentifier, uint64_t currentQuota, uint64_t currentUsage, uint64_t spaceRequested);
    345347
    346348    WebsiteDataStore* websiteDataStoreFromSessionID(PAL::SessionID);

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in

    r289247 r289474  
    7171
    7272    RequestStorageSpace(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired) -> (std::optional<uint64_t> newQuota) Async
     73    IncreaseQuota(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, WebKit::QuotaIncreaseRequestIdentifier identifier, uint64_t quota, uint64_t currentSize, uint64_t spaceRequested)
    7374   
    7475    ResourceLoadDidSendRequest(WebKit::WebPageProxyIdentifier pageIdentifier, struct WebKit::ResourceLoadInfo resourceLoadInfo, WebCore::ResourceRequest request, std::optional<IPC::FormDataReference> httpBody)

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp

    r288238 r289474  
    17171717{
    17181718    // FIXME: Consider whether allowing to set a perThirdPartyOriginStorageQuota from a WebsiteDataStore.
    1719     return WebCore::StorageQuotaManager::defaultThirdPartyQuotaFromPerOriginQuota(perOriginStorageQuota());
     1719    return perOriginStorageQuota() / 10;
    17201720}
    17211721

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h

    r288387 r289474  
    351351    static WTF::String defaultJavaScriptConfigurationDirectory();
    352352    static bool http3Enabled();
     353    static constexpr uint64_t defaultPerOriginQuota() { return 1000 * MB; }
    353354
    354355    void resetQuota(CompletionHandler<void()>&&);

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreConfiguration.cpp

    r289150 r289474  
    3434WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration(IsPersistent isPersistent, WillCopyPathsFromExistingConfiguration willCopyPaths)
    3535    : m_isPersistent(isPersistent)
     36    , m_perOriginStorageQuota(WebsiteDataStore::defaultPerOriginQuota())
    3637{
    3738    if (isPersistent == IsPersistent::Yes && willCopyPaths == WillCopyPathsFromExistingConfiguration::No) {

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreConfiguration.h

    r287781 r289474  
    2727
    2828#include "APIObject.h"
    29 #include <WebCore/StorageQuotaManager.h>
    3029#include <wtf/URL.h>
    3130#include <wtf/text/WTFString.h>
    … …  
    208207    String m_cacheStorageDirectory;
    209208    String m_generalStorageDirectory;
    210     uint64_t m_perOriginStorageQuota { WebCore::StorageQuotaManager::defaultQuota() };
     209    uint64_t m_perOriginStorageQuota;
    211210    String m_networkCacheDirectory;
    212211    String m_applicationCacheDirectory;

  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r289379 r289474  
    14731473                93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B26145227D147000B97A76 /* LocalStorageDatabase.h */; };
    14741474                93B2614F227D14B100B97A76 /* LocalStorageDatabaseTracker.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B26146227D147100B97A76 /* LocalStorageDatabaseTracker.h */; };
     1475                93B631E527ABA62800443A44 /* IDBStorageConnectionToClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B631E427ABA62700443A44 /* IDBStorageConnectionToClient.h */; };
     1476                93B631E827ABA65D00443A44 /* IDBStorageManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B631E627ABA65C00443A44 /* IDBStorageManager.h */; };
     1477                93B631ED27ABA6B400443A44 /* IDBStorageRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B631EB27ABA6B300443A44 /* IDBStorageRegistry.h */; };
     1478                93B631F127ABACA900443A44 /* QuotaManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B631EF27ABACA900443A44 /* QuotaManager.h */; };
     1479                93B631F327ABAD8000443A44 /* QuotaIncreaseRequestIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B631F227ABAD7F00443A44 /* QuotaIncreaseRequestIdentifier.h */; };
    14751480                93BDEB01171DD7AF00BFEE1B /* WKPageLoadTypesPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 93BDEB00171DD7AF00BFEE1B /* WKPageLoadTypesPrivate.h */; settings = {ATTRIBUTES = (Private, ); }; };
    14761481                93D6B772254BB5190058DD3A /* SpeechRecognitionServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 93D6B76C254B89580058DD3A /* SpeechRecognitionServer.h */; };
    … …  
    53785383                93B2614A227D147200B97A76 /* StorageManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageManager.cpp; sourceTree = "<group>"; };
    53795384                93B2614C227D147200B97A76 /* LocalStorageDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LocalStorageDatabase.cpp; sourceTree = "<group>"; };
     5385                93B631E327ABA5F700443A44 /* IDBStorageConnectionToClient.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = IDBStorageConnectionToClient.cpp; sourceTree = "<group>"; };
     5386                93B631E427ABA62700443A44 /* IDBStorageConnectionToClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBStorageConnectionToClient.h; sourceTree = "<group>"; };
     5387                93B631E627ABA65C00443A44 /* IDBStorageManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBStorageManager.h; sourceTree = "<group>"; };
     5388                93B631E727ABA65C00443A44 /* IDBStorageManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBStorageManager.cpp; sourceTree = "<group>"; };
     5389                93B631EA27ABA6B200443A44 /* IDBStorageRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBStorageRegistry.cpp; sourceTree = "<group>"; };
     5390                93B631EB27ABA6B300443A44 /* IDBStorageRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBStorageRegistry.h; sourceTree = "<group>"; };
     5391                93B631EE27ABACA800443A44 /* QuotaManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = QuotaManager.cpp; sourceTree = "<group>"; };
     5392                93B631EF27ABACA900443A44 /* QuotaManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QuotaManager.h; sourceTree = "<group>"; };
     5393                93B631F227ABAD7F00443A44 /* QuotaIncreaseRequestIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QuotaIncreaseRequestIdentifier.h; sourceTree = "<group>"; };
    53805394                93BA04DA2151ADF3007F455F /* WebSWServerConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWServerConnection.messages.in; sourceTree = "<group>"; };
    53815395                93BA04DB2151ADF3007F455F /* WebSWServerToContextConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSWServerToContextConnection.h; sourceTree = "<group>"; };
    … …  
    75937607                        isa = PBXGroup;
    75947608                        children = (
     7609                                93B631F227ABAD7F00443A44 /* QuotaIncreaseRequestIdentifier.h */,
    75957610                                1A4832D41A9CDF96008B4DFE /* WebsiteData.cpp */,
    75967611                                1A4832D51A9CDF96008B4DFE /* WebsiteData.h */,
    … …  
    1047010485                                931A075126F06310004474CD /* FileSystemStorageManager.cpp */,
    1047110486                                931A075026F06310004474CD /* FileSystemStorageManager.h */,
     10487                                93B631E327ABA5F700443A44 /* IDBStorageConnectionToClient.cpp */,
     10488                                93B631E427ABA62700443A44 /* IDBStorageConnectionToClient.h */,
     10489                                93B631E727ABA65C00443A44 /* IDBStorageManager.cpp */,
     10490                                93B631E627ABA65C00443A44 /* IDBStorageManager.h */,
     10491                                93B631EA27ABA6B200443A44 /* IDBStorageRegistry.cpp */,
     10492                                93B631EB27ABA6B300443A44 /* IDBStorageRegistry.h */,
    1047210493                                93E799C92760497A0074008A /* LocalStorageManager.cpp */,
    1047310494                                93E799CB2760497A0074008A /* LocalStorageManager.h */,
    … …  
    1047910500                                93085DC526E1C6CF000EC6A7 /* OriginStorageManager.cpp */,
    1048010501                                93085DC626E1C6CF000EC6A7 /* OriginStorageManager.h */,
     10502                                93B631EE27ABACA800443A44 /* QuotaManager.cpp */,
     10503                                93B631EF27ABACA900443A44 /* QuotaManager.h */,
    1048110504                                93E799CC2760497B0074008A /* SessionStorageManager.cpp */,
    1048210505                                93E799CA2760497A0074008A /* SessionStorageManager.h */,
    … …  
    1308913112                                839A2F321E2067450039057E /* HighPerformanceGraphicsUsageSampler.h in Headers */,
    1309013113                                51C0C9741DDD76000032CAD3 /* IconLoadingDelegate.h in Headers */,
     13114                                93B631E527ABA62800443A44 /* IDBStorageConnectionToClient.h in Headers */,
     13115                                93B631E827ABA65D00443A44 /* IDBStorageManager.h in Headers */,
     13116                                93B631ED27ABA6B400443A44 /* IDBStorageRegistry.h in Headers */,
    1309113117                                51E351CB180F2CCC00E53BE9 /* IDBUtilities.h in Headers */,
    1309213118                                BCCF6B2512C93E7A008F9C35 /* ImageOptions.h in Headers */,
    … …  
    1330313329                                1A0C227E2451130A00ED614D /* QuickLookThumbnailingSoftLink.h in Headers */,
    1330413330                                1AEE57252409F142002005D6 /* QuickLookThumbnailLoader.h in Headers */,
     13331                                93B631F327ABAD8000443A44 /* QuotaIncreaseRequestIdentifier.h in Headers */,
     13332                                93B631F127ABACA900443A44 /* QuotaManager.h in Headers */,
    1330513333                                5CB6AE442609799C00B6ED5A /* ReasonSPI.h in Headers */,
    1330613334                                57FD318222B3515E008D0E8B /* RedirectSOAuthorizationSession.h in Headers */,

  • trunk/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp

    r280053 r289474  
    3030#include "NetworkConnectionToWebProcessMessages.h"
    3131#include "NetworkProcessConnection.h"
     32#include "NetworkStorageManagerMessages.h"
    3233#include "WebCoreArgumentCoders.h"
    3334#include "WebIDBResult.h"
    34 #include "WebIDBServerMessages.h"
    3535#include "WebProcess.h"
    3636#include <WebCore/IDBConnectionToServer.h>
    … …  
    8383void WebIDBConnectionToServer::deleteDatabase(const IDBRequestData& requestData)
    8484{
    85     send(Messages::WebIDBServer::DeleteDatabase(requestData));
     85    send(Messages::NetworkStorageManager::DeleteDatabase(requestData));
    8686}
    8787
    8888void WebIDBConnectionToServer::openDatabase(const IDBRequestData& requestData)
    8989{
    90     send(Messages::WebIDBServer::OpenDatabase(requestData));
     90    send(Messages::NetworkStorageManager::OpenDatabase(requestData));
    9191}
    9292
    9393void WebIDBConnectionToServer::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
    9494{
    95     send(Messages::WebIDBServer::AbortTransaction(transactionIdentifier));
     95    send(Messages::NetworkStorageManager::AbortTransaction(transactionIdentifier));
    9696}
    9797
    9898void WebIDBConnectionToServer::commitTransaction(const IDBResourceIdentifier& transactionIdentifier, uint64_t pendingRequestCount)
    9999{
    100     send(Messages::WebIDBServer::CommitTransaction(transactionIdentifier, pendingRequestCount));
     100    send(Messages::NetworkStorageManager::CommitTransaction(transactionIdentifier, pendingRequestCount));
    101101}
    102102
    103103void WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    104104{
    105     send(Messages::WebIDBServer::DidFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier));
     105    send(Messages::NetworkStorageManager::DidFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier));
    106106}
    107107
    108108void WebIDBConnectionToServer::createObjectStore(const IDBRequestData& requestData, const IDBObjectStoreInfo& info)
    109109{
    110     send(Messages::WebIDBServer::CreateObjectStore(requestData, info));
     110    send(Messages::NetworkStorageManager::CreateObjectStore(requestData, info));
    111111}
    112112
    113113void WebIDBConnectionToServer::deleteObjectStore(const IDBRequestData& requestData, const String& objectStoreName)
    114114{
    115     send(Messages::WebIDBServer::DeleteObjectStore(requestData, objectStoreName));
     115    send(Messages::NetworkStorageManager::DeleteObjectStore(requestData, objectStoreName));
    116116}
    117117
    118118void WebIDBConnectionToServer::renameObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& newName)
    119119{
    120     send(Messages::WebIDBServer::RenameObjectStore(requestData, objectStoreIdentifier, newName));
     120    send(Messages::NetworkStorageManager::RenameObjectStore(requestData, objectStoreIdentifier, newName));
    121121}
    122122
    123123void WebIDBConnectionToServer::clearObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier)
    124124{
    125     send(Messages::WebIDBServer::ClearObjectStore(requestData, objectStoreIdentifier));
     125    send(Messages::NetworkStorageManager::ClearObjectStore(requestData, objectStoreIdentifier));
    126126}
    127127
    128128void WebIDBConnectionToServer::createIndex(const IDBRequestData& requestData, const IDBIndexInfo& info)
    129129{
    130     send(Messages::WebIDBServer::CreateIndex(requestData, info));
     130    send(Messages::NetworkStorageManager::CreateIndex(requestData, info));
    131131}
    132132
    133133void WebIDBConnectionToServer::deleteIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
    134134{
    135     send(Messages::WebIDBServer::DeleteIndex(requestData, objectStoreIdentifier, indexName));
     135    send(Messages::NetworkStorageManager::DeleteIndex(requestData, objectStoreIdentifier, indexName));
    136136}
    137137
    138138void WebIDBConnectionToServer::renameIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
    139139{
    140     send(Messages::WebIDBServer::RenameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName));
     140    send(Messages::NetworkStorageManager::RenameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName));
    141141}
    142142
    143143void WebIDBConnectionToServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode mode)
    144144{
    145     send(Messages::WebIDBServer::PutOrAdd(requestData, keyData, value, mode));
     145    send(Messages::NetworkStorageManager::PutOrAdd(requestData, keyData, value, mode));
    146146}
    147147
    148148void WebIDBConnectionToServer::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData)
    149149{
    150     send(Messages::WebIDBServer::GetRecord(requestData, getRecordData));
     150    send(Messages::NetworkStorageManager::GetRecord(requestData, getRecordData));
    151151}
    152152
    153153void WebIDBConnectionToServer::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData)
    154154{
    155     send(Messages::WebIDBServer::GetAllRecords(requestData, getAllRecordsData));
     155    send(Messages::NetworkStorageManager::GetAllRecords(requestData, getAllRecordsData));
    156156}
    157157
    158158void WebIDBConnectionToServer::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& range)
    159159{
    160     send(Messages::WebIDBServer::GetCount(requestData, range));
     160    send(Messages::NetworkStorageManager::GetCount(requestData, range));
    161161}
    162162
    163163void WebIDBConnectionToServer::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& range)
    164164{
    165     send(Messages::WebIDBServer::DeleteRecord(requestData, range));
     165    send(Messages::NetworkStorageManager::DeleteRecord(requestData, range));
    166166}
    167167
    168168void WebIDBConnectionToServer::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info)
    169169{
    170     send(Messages::WebIDBServer::OpenCursor(requestData, info));
     170    send(Messages::NetworkStorageManager::OpenCursor(requestData, info));
    171171}
    172172
    173173void WebIDBConnectionToServer::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data)
    174174{
    175     send(Messages::WebIDBServer::IterateCursor(requestData, data));
     175    send(Messages::NetworkStorageManager::IterateCursor(requestData, data));
    176176}
    177177
    178178void WebIDBConnectionToServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
    179179{
    180     send(Messages::WebIDBServer::EstablishTransaction(databaseConnectionIdentifier, info));
     180    send(Messages::NetworkStorageManager::EstablishTransaction(databaseConnectionIdentifier, info));
    181181}
    182182
    183183void WebIDBConnectionToServer::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
    184184{
    185     send(Messages::WebIDBServer::DatabaseConnectionPendingClose(databaseConnectionIdentifier));
     185    send(Messages::NetworkStorageManager::DatabaseConnectionPendingClose(databaseConnectionIdentifier));
    186186}
    187187
    188188void WebIDBConnectionToServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
    189189{
    190     send(Messages::WebIDBServer::DatabaseConnectionClosed(databaseConnectionIdentifier));
     190    send(Messages::NetworkStorageManager::DatabaseConnectionClosed(databaseConnectionIdentifier));
    191191}
    192192
    193193void WebIDBConnectionToServer::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    194194{
    195     send(Messages::WebIDBServer::AbortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier));
     195    send(Messages::NetworkStorageManager::AbortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier));
    196196}
    197197
    198198void WebIDBConnectionToServer::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, const IndexedDB::ConnectionClosedOnBehalfOfServer connectionClosed)
    199199{
    200     send(Messages::WebIDBServer::DidFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, connectionClosed));
     200    send(Messages::NetworkStorageManager::DidFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, connectionClosed));
    201201}
    202202
    203203void WebIDBConnectionToServer::openDBRequestCancelled(const IDBRequestData& requestData)
    204204{
    205     send(Messages::WebIDBServer::OpenDBRequestCancelled(requestData));
     205    send(Messages::NetworkStorageManager::OpenDBRequestCancelled(requestData));
    206206}
    207207
    208208void WebIDBConnectionToServer::getAllDatabaseNamesAndVersions(const IDBResourceIdentifier& requestIdentifier, const ClientOrigin& origin)
    209209{
    210     send(Messages::WebIDBServer::GetAllDatabaseNamesAndVersions(requestIdentifier, origin));
     210    send(Messages::NetworkStorageManager::GetAllDatabaseNamesAndVersions(requestIdentifier, origin));
    211211}
    212212

  • trunk/Source/WebKitLegacy/ChangeLog

    r289017 r289474  
     12022-02-09  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 Chris Dumez.
     8
     9        * Storage/InProcessIDBServer.cpp:
     10        (InProcessIDBServer::quotaManager):
     11
    1122022-02-02  Elliott Williams  <emw@apple.com>
    213

  • trunk/Source/WebKitLegacy/Storage/InProcessIDBServer.cpp

    r284162 r289474  
    4343using namespace WebCore;
    4444
     45static constexpr uint64_t defaultPerOriginQuota =  1000 * MB;
     46
    4547Ref<InProcessIDBServer> InProcessIDBServer::create(PAL::SessionID sessionID)
    4648{
    … …  
    7476{
    7577    return m_quotaManagers.ensure(origin, [] {
    76         return StorageQuotaManager::create(StorageQuotaManager::defaultQuota(), [] {
     78        return StorageQuotaManager::create(defaultPerOriginQuota, [] {
    7779            return 0;
    7880        }, [](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {

  • trunk/Tools/ChangeLog

    r289470 r289474  
     12022-02-09  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 Chris Dumez.
     8
     9        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBFileName.mm:
     10        (runTest):
     11        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm:
     12        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBSuspendImminently.mm:
     13        (TEST):
     14        * TestWebKitAPI/Tests/WebKitCocoa/StoreBlobThenDelete.mm:
     15        (TEST):
     16
    1172022-02-09  Martin Robinson  <mrobinson@webkit.org>
    218

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBFileName.mm

    r285547 r289474  
    7272    EXPECT_WK_STREQ(@"Success", string2.get());
    7373
    74     // For database that is not opened after upgrade, its file should be in v0.
     74    // All databases of an origin are migrated to new version directory when the origin is accessed.
    7575    auto defaultFileManager = [NSFileManager defaultManager];
    7676    NSString *existingDatabaseName = @"IndexedDBTest";
    … …  
    7979    NSString *existingDatbaseHash = WebCore::SQLiteFileSystem::computeHashForFileName(existingDatabaseName);
    8080    NSString *createdDatabaseHash = WebCore::SQLiteFileSystem::computeHashForFileName(createdDatabaseName);
     81    NSString *unusedDatabaseHash = WebCore::SQLiteFileSystem::computeHashForFileName(createdDatabaseName);
    8182    NSURL *idbRootURL = [[WKWebsiteDataStore defaultDataStore] _indexedDBDatabaseDirectory];
    8283    NSURL *oldVersionDirectoryURL = [idbRootURL URLByAppendingPathComponent:@"v0"];
    … …  
    8586    NSURL *newVersionOriginDirectoryURL = [newVersionDirectoryURL URLByAppendingPathComponent: @"file__0"];
    8687    NSURL *oldVersionUnusedDatabaseDirectoryURL = [oldVersionOriginDirectoryURL URLByAppendingPathComponent:unusedDatabaseName];
    87     EXPECT_TRUE([[NSFileManager defaultManager] fileExistsAtPath:oldVersionUnusedDatabaseDirectoryURL.path]);
     88    NSURL *newVersionUnusedDatabaseDirectoryURL = [newVersionOriginDirectoryURL URLByAppendingPathComponent:unusedDatabaseHash];
     89    EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:oldVersionUnusedDatabaseDirectoryURL.path]);
     90    EXPECT_TRUE([[NSFileManager defaultManager] fileExistsAtPath:newVersionUnusedDatabaseDirectoryURL.path]);
    8891   
    8992    // For database that is opened after upgrade, its file should only be in v1.

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm

    r288098 r289474  
    306306
    307307    readyToContinue = false;
    308     [[WKWebsiteDataStore defaultDataStore] fetchDataRecordsOfTypes:websiteDataTypes.get() completionHandler:^(NSArray<WKWebsiteDataRecord *> *dataRecords) {
    309         EXPECT_EQ(1u, dataRecords.count);
    310         EXPECT_WK_STREQ("iframe", [[dataRecords firstObject] displayName]);
    311         [[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:websiteDataTypes.get() forDataRecords:dataRecords completionHandler:^() {
     308    [[WKWebsiteDataStore defaultDataStore] fetchDataRecordsOfTypes:websiteDataTypes.get() completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
     309        EXPECT_EQ(2u, records.count);
     310        NSSortDescriptor *recordDescriptor = [NSSortDescriptor sortDescriptorWithKey:@"displayName" ascending:YES];
     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:^() {
    312316            readyToContinue = true;
    313317        }];

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBSuspendImminently.mm

    r285547 r289474  
    7474TEST(IndexedDB, IndexedDBSuspendImminently)
    7575{
     76    readyToContinue = false;
     77    [[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:[WKWebsiteDataStore allWebsiteDataTypes] modifiedSince:[NSDate distantPast] completionHandler:^() {
     78        readyToContinue = true;
     79    }];
     80    TestWebKitAPI::Util::run(&readyToContinue);
     81
    7682    auto handler = adoptNS([[IndexedDBSuspendImminentlyMessageHandler alloc] init]);
    7783    auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/StoreBlobThenDelete.mm

    r285547 r289474  
    8888    [[NSFileManager defaultManager] copyItemAtPath:databaseFilePath toPath:fakeWalPath error:nil];
    8989
    90     // Make some other .blob files in the database directory to later validate that only appropriate files are deleted.
     90    // Make some other .blob files in the database directory to later validate all blob files in the directory are deleted.
    9191    NSString *otherBlob1 = [databaseDirectory stringByAppendingPathComponent:@"7182.blob"];
    9292    NSString *otherBlob2 = [databaseDirectory stringByAppendingPathComponent:@"1a.blob"];
    … …  
    103103        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:databaseFilePath]);
    104104
    105         // Make sure the fake blob file with a valid blob file name is gone.
     105        // Make sure all fake blob file are gone.
    106106        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob1]);
    107107
    108         // Make sure the fake blob files with invalid blob file names are still there.
    109         EXPECT_TRUE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob2]);
    110         EXPECT_TRUE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob3]);
    111         EXPECT_TRUE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob4]);
     108        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob2]);
     109        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob3]);
     110        EXPECT_FALSE([[NSFileManager defaultManager] fileExistsAtPath:otherBlob4]);
    112111
    113112        // Make sure everything related to the fake database is gone.
Note: See TracChangeset for help on using the changeset viewer.