Changeset 252839 in webkit

Timestamp:

Nov 23, 2019 7:03:26 PM (4 years ago)

Author:

commit-queue@webkit.org

Message:

Unreviewed, rolling out r252805.
​https://bugs.webkit.org/show_bug.cgi?id=204553

Caused test failures and ASan crashes (Requested by ap on
#webkit).

Reverted changeset:

"Cross-thread version StorageQuotaManager"
​https://bugs.webkit.org/show_bug.cgi?id=203971
​https://trac.webkit.org/changeset/252805

Location:

trunk

Files:

• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/Headers.cmake (modified) (1 diff)
• Source/WebCore/Modules/indexeddb/server/IDBServer.cpp (modified) (3 diffs)
• Source/WebCore/Modules/indexeddb/server/IDBServer.h (modified) (6 diffs)
• Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp (modified) (31 diffs)
• Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h (modified) (6 diffs)
• Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp (modified) (1 diff)
• Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp (modified) (8 diffs)
• Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp (modified) (3 diffs)
• Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.h (modified) (2 diffs)
• Source/WebCore/WebCore.xcodeproj/project.pbxproj (modified) (4 diffs)
• Source/WebCore/storage/StorageQuotaManager.cpp (modified) (1 diff)
• Source/WebCore/storage/StorageQuotaManager.h (modified) (2 diffs)
• Source/WebCore/storage/StorageQuotaUser.h (added)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/NetworkProcess/NetworkProcess.cpp (modified) (11 diffs)
• Source/WebKit/NetworkProcess/NetworkProcess.h (modified) (5 diffs)
• Source/WebKit/NetworkProcess/NetworkProcess.messages.in (modified) (1 diff)
• Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp (modified) (5 diffs)
• Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h (modified) (3 diffs)
• Source/WebKit/NetworkProcess/cache/CacheStorageEngineCache.cpp (modified) (2 diffs)
• Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp (modified) (12 diffs)
• Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.h (modified) (5 diffs)
• Source/WebKit/Shared/WebsiteDataStoreParameters.cpp (modified) (2 diffs)
• Source/WebKit/Shared/WebsiteDataStoreParameters.h (modified) (1 diff)
• Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.cpp (modified) (1 diff)
• Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.h (modified) (1 diff)
• Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp (modified) (1 diff)
• Source/WebKit/UIProcess/Network/NetworkProcessProxy.h (modified) (2 diffs)
• Source/WebKit/UIProcess/WebProcessPool.cpp (modified) (1 diff)
• Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm (modified) (1 diff)
• Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp (modified) (2 diffs)
• Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj (modified) (8 diffs)
• Tools/TestWebKitAPI/Tests/WebCore/StorageQuotaManager.cpp (added)
• Tools/WebKitTestRunner/TestController.cpp (modified) (2 diffs)
• Tools/WebKitTestRunner/TestController.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-11-23  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r252805.
+        https://bugs.webkit.org/show_bug.cgi?id=204553
+
+        Caused test failures and ASan crashes (Requested by ap on
+        #webkit).
+
+        Reverted changeset:
+
+        "Cross-thread version StorageQuotaManager"
+        https://bugs.webkit.org/show_bug.cgi?id=203971
+        https://trac.webkit.org/changeset/252805
+
 2019-11-23  Zalan Bujtas  <zalan@apple.com>
 

trunk/Source/WebCore/Headers.cmake

@@ -1382 +1382 @@
     storage/StorageNamespaceProvider.h
     storage/StorageQuotaManager.h
+    storage/StorageQuotaUser.h
     storage/StorageType.h
 

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

@@ -47 +47 @@
 namespace IDBServer {
 
-Ref<IDBServer> IDBServer::create(PAL::SessionID sessionID, StorageQuotaManagerSpaceRequester&& quotaManagerGetter)
+Ref<IDBServer> IDBServer::create(PAL::SessionID sessionID, QuotaManagerGetter&& quotaManagerGetter)
 {
     return adoptRef(*new IDBServer(sessionID, WTFMove(quotaManagerGetter)));
 }
 
-Ref<IDBServer> IDBServer::create(PAL::SessionID sessionID, const String& databaseDirectoryPath, StorageQuotaManagerSpaceRequester&& quotaManagerGetter)
+Ref<IDBServer> IDBServer::create(PAL::SessionID sessionID, const String& databaseDirectoryPath, QuotaManagerGetter&& quotaManagerGetter)
 {
     return adoptRef(*new IDBServer(sessionID, databaseDirectoryPath, WTFMove(quotaManagerGetter)));
 }
 
-IDBServer::IDBServer(PAL::SessionID sessionID, StorageQuotaManagerSpaceRequester&& spaceRequester)
+IDBServer::IDBServer(PAL::SessionID sessionID, QuotaManagerGetter&& quotaManagerGetter)
     : CrossThreadTaskHandler("IndexedDatabase Server", AutodrainedPoolForRunLoop::Use)
     , m_sessionID(sessionID)
-    , m_spaceRequester(WTFMove(spaceRequester))
-{
-}
-
-IDBServer::IDBServer(PAL::SessionID sessionID, const String& databaseDirectoryPath, StorageQuotaManagerSpaceRequester&& spaceRequester)
+    , m_quotaManagerGetter(WTFMove(quotaManagerGetter))
+{
+}
+
+IDBServer::IDBServer(PAL::SessionID sessionID, const String& databaseDirectoryPath, QuotaManagerGetter&& quotaManagerGetter)
     : CrossThreadTaskHandler("IndexedDatabase Server", AutodrainedPoolForRunLoop::Use)
     , m_sessionID(sessionID)
     , m_databaseDirectoryPath(databaseDirectoryPath)
-    , m_spaceRequester(WTFMove(spaceRequester))
+    , m_quotaManagerGetter(WTFMove(quotaManagerGetter))
 {
     LOG(IndexedDB, "IDBServer created at path %s", databaseDirectoryPath.utf8().data());
@@ -684 +684 @@
 void IDBServer::didPerformCloseAndDeleteDatabases(uint64_t callbackID)
 {
+    for (auto& user : m_quotaUsers.values())
+        user->resetSpaceUsed();
+
     auto callback = m_deleteDatabaseCompletionHandlers.take(callbackID);
     ASSERT(callback);
@@ -689 +692 @@
 }
 
-StorageQuotaManager::Decision IDBServer::requestSpace(const ClientOrigin& origin, uint64_t taskSize)
+IDBServer::QuotaUser::QuotaUser(IDBServer& server, StorageQuotaManager* manager, ClientOrigin&& origin)
+    : m_server(server)
+    , m_manager(makeWeakPtr(manager))
+    , m_origin(WTFMove(origin))
+    , m_isInitialized(m_server.m_sessionID.isEphemeral())
+{
+    if (manager)
+        manager->addUser(*this);
+}
+
+IDBServer::QuotaUser::~QuotaUser()
+{
+    if (m_manager)
+        m_manager->removeUser(*this);
+}
+
+void IDBServer::QuotaUser::resetSpaceUsed()
+{
+    m_spaceUsed = 0;
+
+    if (!m_manager)
+        return;
+
+    if (m_server.m_sessionID.isEphemeral())
+        return;
+
+    if (!m_isInitialized)
+        return;
+
+    ASSERT(!m_initializationCallback);
+
+    m_isInitialized = false;
+
+    // Do add/remove to trigger call to whenInitialized.
+    m_manager->removeUser(*this);
+    m_manager->addUser(*this);
+}
+
+void IDBServer::QuotaUser::computeSpaceUsed()
+{
+    resetSpaceUsed();
+}
+
+void IDBServer::QuotaUser::increaseSpaceUsed(uint64_t size)
+{
+    if (!m_isInitialized)
+        return;
+    ASSERT(m_spaceUsed + size > m_spaceUsed);
+    m_spaceUsed += size;
+}
+void IDBServer::QuotaUser::decreaseSpaceUsed(uint64_t size)
+{
+    if (!m_isInitialized)
+        return;
+    ASSERT(m_spaceUsed >= size);
+    m_spaceUsed -= size;
+}
+
+void IDBServer::QuotaUser::whenInitialized(CompletionHandler<void()>&& callback)
+{
+    if (m_isInitialized) {
+        callback();
+        return;
+    }
+    m_initializationCallback = WTFMove(callback);
+    m_server.startComputingSpaceUsedForOrigin(m_origin);
+}
+
+void IDBServer::QuotaUser::initializeSpaceUsed(uint64_t spaceUsed)
+{
+    ASSERT(m_isInitialized || !m_estimatedSpaceIncrease);
+    m_spaceUsed = spaceUsed;
+    m_isInitialized = true;
+
+    if (auto callback = WTFMove(m_initializationCallback))
+        callback();
+}
+
+IDBServer::QuotaUser& IDBServer::ensureQuotaUser(const ClientOrigin& origin)
+{
+    return *m_quotaUsers.ensure(origin, [this, &origin] {
+        return makeUnique<QuotaUser>(*this, m_quotaManagerGetter(m_sessionID, origin), ClientOrigin { origin });
+    }).iterator->value;
+}
+
+void IDBServer::startComputingSpaceUsedForOrigin(const ClientOrigin& origin)
+{
+    ASSERT(!m_sessionID.isEphemeral());
+    postDatabaseTask(createCrossThreadTask(*this, &IDBServer::computeSpaceUsedForOrigin, origin));
+}
+
+void IDBServer::computeSpaceUsedForOrigin(const ClientOrigin& origin)
 {
     ASSERT(!isMainThread());
-    return m_spaceRequester(origin, taskSize);
-}
-
-uint64_t IDBServer::diskUsage(const String& rootDirectory, const ClientOrigin& origin)
-{
-    ASSERT(!isMainThread());
-
-    auto oldVersionOriginDirectory = IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(origin.topOrigin, origin.clientOrigin, rootDirectory, "v0"_str);
-    auto newVersionOriginDirectory = IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(origin.topOrigin, origin.clientOrigin, rootDirectory, "v1"_str);
-    return SQLiteIDBBackingStore::databasesSizeForDirectory(oldVersionOriginDirectory) + SQLiteIDBBackingStore::databasesSizeForDirectory(newVersionOriginDirectory);
+
+    auto databaseDirectoryPath = this->databaseDirectoryPathIsolatedCopy();
+    auto oldVersionOriginDirectory = IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(origin.topOrigin, origin.clientOrigin, databaseDirectoryPath, "v0");
+    auto newVersionOriginDirectory = IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(origin.topOrigin, origin.clientOrigin, databaseDirectoryPath, "v1");
+    auto size = SQLiteIDBBackingStore::databasesSizeForDirectory(oldVersionOriginDirectory) + SQLiteIDBBackingStore::databasesSizeForDirectory(newVersionOriginDirectory);
+
+    postDatabaseTaskReply(createCrossThreadTask(*this, &IDBServer::finishComputingSpaceUsedForOrigin, origin, size));
+}
+
+void IDBServer::finishComputingSpaceUsedForOrigin(const ClientOrigin& origin, uint64_t spaceUsed)
+{
+    ensureQuotaUser(origin).initializeSpaceUsed(spaceUsed);
+}
+
+void IDBServer::requestSpace(const ClientOrigin& origin, uint64_t taskSize, CompletionHandler<void(StorageQuotaManager::Decision)>&& callback)
+{
+    auto* quotaManager = ensureQuotaUser(origin).manager();
+    if (!quotaManager) {
+        callback(StorageQuotaManager::Decision::Deny);
+        return;
+    }
+
+    quotaManager->requestSpace(taskSize, WTFMove(callback));
+}
+
+void IDBServer::resetSpaceUsed(const ClientOrigin& origin)
+{
+    if (auto* user = m_quotaUsers.get(origin))
+        user->resetSpaceUsed();
+}
+
+void IDBServer::increaseSpaceUsed(const ClientOrigin& origin, uint64_t size)
+{
+    ensureQuotaUser(origin).increaseSpaceUsed(size);
+}
+
+void IDBServer::decreaseSpaceUsed(const ClientOrigin& origin, uint64_t size)
+{
+    ensureQuotaUser(origin).decreaseSpaceUsed(size);
+}
+
+void IDBServer::increasePotentialSpaceUsed(const ClientOrigin& origin, uint64_t taskSize)
+{
+    ensureQuotaUser(origin).increasePotentialSpaceUsed(taskSize);
+}
+
+void IDBServer::decreasePotentialSpaceUsed(const ClientOrigin& origin, uint64_t spaceUsed)
+{
+    ensureQuotaUser(origin).decreasePotentialSpaceUsed(spaceUsed);
 }
 

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

@@ -31 +31 @@
 #include "IDBDatabaseIdentifier.h"
 #include "StorageQuotaManager.h"
+#include "StorageQuotaUser.h"
 #include "UniqueIDBDatabase.h"
 #include "UniqueIDBDatabaseConnection.h"
@@ -58 +59 @@
 class IDBServer : public RefCounted<IDBServer>, public CrossThreadTaskHandler, public CanMakeWeakPtr<IDBServer> {
 public:
-    using StorageQuotaManagerSpaceRequester = Function<StorageQuotaManager::Decision(const ClientOrigin&, uint64_t spaceRequested)>;
-    static Ref<IDBServer> create(PAL::SessionID, StorageQuotaManagerSpaceRequester&&);
-    WEBCORE_EXPORT static Ref<IDBServer> create(PAL::SessionID, const String& databaseDirectoryPath, StorageQuotaManagerSpaceRequester&&);
+    using QuotaManagerGetter = WTF::Function<StorageQuotaManager*(PAL::SessionID, const ClientOrigin&)>;
+    static Ref<IDBServer> create(PAL::SessionID, QuotaManagerGetter&&);
+    WEBCORE_EXPORT static Ref<IDBServer> create(PAL::SessionID, const String& databaseDirectoryPath, QuotaManagerGetter&&);
 
     WEBCORE_EXPORT void registerConnection(IDBConnectionToClient&);
@@ -111 +112 @@
     WEBCORE_EXPORT void closeAndDeleteDatabasesForOrigins(const Vector<SecurityOriginData>&, Function<void ()>&& completionHandler);
 
-    StorageQuotaManager::Decision requestSpace(const ClientOrigin&, uint64_t taskSize);
-    WEBCORE_EXPORT static uint64_t diskUsage(const String& rootDirectory, const ClientOrigin&);
+    void requestSpace(const ClientOrigin&, uint64_t taskSize, CompletionHandler<void(StorageQuotaManager::Decision)>&&);
+    void increasePotentialSpaceUsed(const ClientOrigin&, uint64_t taskSize);
+    void decreasePotentialSpaceUsed(const ClientOrigin&, uint64_t taskSize);
+    void increaseSpaceUsed(const ClientOrigin&, uint64_t size);
+    void decreaseSpaceUsed(const ClientOrigin&, uint64_t size);
+    void resetSpaceUsed(const ClientOrigin&);
+
+    void initializeQuotaUser(const ClientOrigin& origin) { ensureQuotaUser(origin); }
 
     WEBCORE_EXPORT void tryStop(ShouldForceStop);
@@ -121 +128 @@
 
 private:
-    IDBServer(PAL::SessionID, StorageQuotaManagerSpaceRequester&&);
-    IDBServer(PAL::SessionID, const String& databaseDirectoryPath, StorageQuotaManagerSpaceRequester&&);
+    IDBServer(PAL::SessionID, QuotaManagerGetter&&);
+    IDBServer(PAL::SessionID, const String& databaseDirectoryPath, QuotaManagerGetter&&);
 
     UniqueIDBDatabase& getOrCreateUniqueIDBDatabase(const IDBDatabaseIdentifier&);
@@ -138 +145 @@
     void removeDatabasesModifiedSinceForVersion(WallTime, const String&);
     void removeDatabasesWithOriginsForVersion(const Vector<SecurityOriginData>&, const String&);
+
+    class QuotaUser final : public StorageQuotaUser {
+        WTF_MAKE_FAST_ALLOCATED;
+    public:
+        QuotaUser(IDBServer&, StorageQuotaManager*, ClientOrigin&&);
+        ~QuotaUser();
+
+        StorageQuotaManager* manager() { return m_manager.get(); }
+
+        void setSpaceUsed(uint64_t spaceUsed) { m_spaceUsed = spaceUsed; }
+        void resetSpaceUsed();
+
+        void increasePotentialSpaceUsed(uint64_t increase) { m_estimatedSpaceIncrease += increase; }
+        void decreasePotentialSpaceUsed(uint64_t decrease)
+        {
+            ASSERT(m_estimatedSpaceIncrease >= decrease);
+            m_estimatedSpaceIncrease -= decrease;
+        }
+        void increaseSpaceUsed(uint64_t size);
+        void decreaseSpaceUsed(uint64_t size);
+
+        void initializeSpaceUsed(uint64_t spaceUsed);
+
+    private:
+        uint64_t spaceUsed() const final
+        {
+            ASSERT(m_isInitialized);
+            return m_spaceUsed + m_estimatedSpaceIncrease;
+        }
+        void computeSpaceUsed() final;
+        void whenInitialized(CompletionHandler<void()>&&) final;
+
+        IDBServer& m_server;
+        WeakPtr<StorageQuotaManager> m_manager;
+        ClientOrigin m_origin;
+        bool m_isInitialized { false };
+        uint64_t m_spaceUsed { 0 };
+        uint64_t m_estimatedSpaceIncrease { 0 };
+        CompletionHandler<void()> m_initializationCallback;
+    };
+
+    WEBCORE_EXPORT QuotaUser& ensureQuotaUser(const ClientOrigin&);
+    void startComputingSpaceUsedForOrigin(const ClientOrigin&);
+    void computeSpaceUsedForOrigin(const ClientOrigin&);
+    void finishComputingSpaceUsedForOrigin(const ClientOrigin&, uint64_t spaceUsed);
 
     PAL::SessionID m_sessionID;
@@ -151 +203 @@
     String m_databaseDirectoryPath;
 
-    StorageQuotaManagerSpaceRequester m_spaceRequester;
+    HashMap<ClientOrigin, std::unique_ptr<QuotaUser>> m_quotaUsers;
+    QuotaManagerGetter m_quotaManagerGetter;
 };
 

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

@@ -190 +190 @@
 }
 
+void UniqueIDBDatabase::requestSpace(UniqueIDBDatabaseTransaction& transaction, uint64_t taskSize, const char* taskName, CompletionHandler<void(IDBError&&)>&& callback)
+{
+    m_server->requestSpace(m_identifier.origin(), taskSize, [weakThis = makeWeakPtr(this), this, weakTransaction = makeWeakPtr(transaction), taskName, callback = WTFMove(callback)](auto decision) mutable {
+        if (!weakThis) {
+            callback(IDBError { UnknownError });
+            return;
+        }
+
+        if (!weakTransaction) {
+            callback(IDBError { UnknownError });
+            return;
+        }
+        if (m_owningPointerForClose) {
+            // We are closing the database, there is no point in trying to modify the database at that point.
+            callback(IDBError { UnknownError });
+            return;
+        }
+
+        switch (decision) {
+        case StorageQuotaManager::Decision::Deny:
+            callback(IDBError { QuotaExceededError, quotaErrorMessageName(taskName) });
+            return;
+        case StorageQuotaManager::Decision::Grant:
+            callback(IDBError { });
+        };
+    });
+}
+
+void UniqueIDBDatabase::waitForRequestSpaceCompletion(UniqueIDBDatabaseTransaction& transaction, CompletionHandler<void(IDBError&&)>&& callback)
+{
+    requestSpace(transaction, 0, "", WTFMove(callback));
+}
+
+void UniqueIDBDatabase::startSpaceIncreaseTask(uint64_t identifier, uint64_t taskSize)
+{
+    m_server->increasePotentialSpaceUsed(m_identifier.origin(), taskSize);
+    ASSERT(!m_pendingSpaceIncreaseTasks.contains(identifier));
+    m_pendingSpaceIncreaseTasks.add(identifier, taskSize);
+}
+
+void UniqueIDBDatabase::finishSpaceIncreaseTask(uint64_t identifier, bool isTaskSuccessful)
+{
+    auto iterator = m_pendingSpaceIncreaseTasks.find(identifier);
+    ASSERT(iterator != m_pendingSpaceIncreaseTasks.end());
+    m_server->decreasePotentialSpaceUsed(m_identifier.origin(), iterator->value);
+    if (isTaskSuccessful)
+        m_server->increaseSpaceUsed(m_identifier.origin(), iterator->value);
+    m_pendingSpaceIncreaseTasks.remove(iterator);
+}
+
 void UniqueIDBDatabase::performCurrentOpenOperation()
 {
@@ -200 +250 @@
         if (!m_isOpeningBackingStore) {
             m_isOpeningBackingStore = true;
-            postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::openBackingStore, m_identifier));
+            // We do not know whether this is an existing or a new database.
+            // We set a small cost so that it is not possible to open an infinite number of database.
+            m_server->requestSpace(m_identifier.origin(), defaultWriteOperationCost, [this, weakThis = makeWeakPtr(this)](auto decision) mutable {
+                if (!weakThis)
+                    return;
+
+                if (m_owningPointerForClose)
+                    return;
+
+                switch (decision) {
+                case StorageQuotaManager::Decision::Deny: {
+                    auto result = IDBResultData::error(m_currentOpenDBRequest->requestData().requestIdentifier(), IDBError { QuotaExceededError, quotaErrorMessageName("openDatabase") });
+                    m_currentOpenDBRequest->connection().didOpenDatabase(result);
+                    m_currentOpenDBRequest = nullptr;
+                    m_isOpeningBackingStore = false;
+                    break;
+                }
+                case StorageQuotaManager::Decision::Grant:
+                    auto callbackID = this->generateUniqueCallbackIdentifier();
+                    startSpaceIncreaseTask(callbackID, defaultWriteOperationCost);
+                    this->postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::openBackingStore, m_identifier, callbackID));
+                };
+            });
         }
         return;
@@ -764 +836 @@
 }
 
-void UniqueIDBDatabase::openBackingStore(const IDBDatabaseIdentifier& identifier)
+void UniqueIDBDatabase::openBackingStore(const IDBDatabaseIdentifier& identifier, uint64_t taskIdentifier)
 {
     ASSERT(!isMainThread());
     LOG(IndexedDB, "(db) UniqueIDBDatabase::openBackingStore (%p)", this);
 
+    ASSERT(!m_backingStore);
+
     IDBDatabaseInfo databaseInfo;
-    m_origin = identifier.origin();
-    // Quota check.
-    auto decision = m_server->requestSpace(m_origin, defaultWriteOperationCost);
-    if (decision == StorageQuotaManager::Decision::Deny) {
-        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenBackingStore, databaseInfo, IDBError(QuotaExceededError, quotaErrorMessageName("OpenBackingStore"))));
-        return;
-    }
-
-    ASSERT(!m_backingStore);
     IDBError error;
     {
@@ -788 +853 @@
     }
 
-    postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenBackingStore, databaseInfo, error));
-}
-
-void UniqueIDBDatabase::didOpenBackingStore(const IDBDatabaseInfo& info, const IDBError& error)
+    postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenBackingStore, databaseInfo, error,  taskIdentifier));
+}
+
+void UniqueIDBDatabase::didOpenBackingStore(const IDBDatabaseInfo& info, const IDBError& error, uint64_t taskIdentifier)
 {
     ASSERT(isMainThread());
@@ -802 +867 @@
     m_isOpeningBackingStore = false;
 
+    finishSpaceIncreaseTask(taskIdentifier, error.isNull());
+
     if (m_hardClosedForUserDelete)
         return;
@@ -813 +880 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::createObjectStore");
 
+    auto taskSize = defaultWriteOperationCost + estimateSize(info);
+    requestSpace(transaction, taskSize, "createObjectStore", [this, taskSize, &transaction, info, callback = WTFMove(callback)](auto error) mutable {
+        if (!error.isNull() && *error.code() != QuotaExceededError) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->createObjectStoreAfterQuotaCheck(taskSize, transaction, info, WTFMove(callback), error);
+    });
+}
+
+void UniqueIDBDatabase::createObjectStoreAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction& transaction, const IDBObjectStoreInfo& info, ErrorCallback callback, const IDBError& quotaError)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
         return;
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performCreateObjectStore, callbackID, transaction.info().identifier(), info));
-}
-
-void UniqueIDBDatabase::performCreateObjectStore(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBObjectStoreInfo& info)
+    startSpaceIncreaseTask(callbackID, taskSize);
+    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performCreateObjectStore, callbackID, transaction.info().identifier(), info,  quotaError));
+}
+
+void UniqueIDBDatabase::performCreateObjectStore(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBObjectStoreInfo& info, const IDBError& quotaError)
 {
     ASSERT(!isMainThread());
     LOG(IndexedDB, "(db) UniqueIDBDatabase::performCreateObjectStore");
 
-    // Quota check.
-    auto taskSize = defaultWriteOperationCost + estimateSize(info);
-    if (m_server->requestSpace(m_origin, taskSize) == StorageQuotaManager::Decision::Deny) {
-        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformCreateObjectStore, callbackIdentifier, IDBError(QuotaExceededError, quotaErrorMessageName("CreateObjectStore")), info));
+    if (!quotaError.isNull()) {
+        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformCreateObjectStore, callbackIdentifier, quotaError, info));
         return;
     }
@@ -847 +925 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformCreateObjectStore");
 
+    finishSpaceIncreaseTask(callbackIdentifier, error.isNull());
     if (error.isNull())
         m_databaseInfo->addExistingObjectStore(info);
@@ -858 +937 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::deleteObjectStore");
 
+    waitForRequestSpaceCompletion(transaction, [this, &transaction, objectStoreName, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->deleteObjectStoreAfterQuotaCheck(transaction, objectStoreName, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::deleteObjectStoreAfterQuotaCheck(UniqueIDBDatabaseTransaction& transaction, const String& objectStoreName, ErrorCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -902 +992 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::renameObjectStore");
 
+    auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
+    requestSpace(transaction, taskSize, "renameObjectStore", [this, taskSize, &transaction, objectStoreIdentifier, newName, callback = WTFMove(callback)](auto error) mutable {
+        if (!error.isNull() && *error.code() != QuotaExceededError) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->renameObjectStoreAfterQuotaCheck(taskSize, transaction, objectStoreIdentifier, newName, WTFMove(callback), error);
+    });
+}
+
+void UniqueIDBDatabase::renameObjectStoreAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback callback, const IDBError& quotaError)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
         return;
 
-    IDBError error;
+    IDBError error = quotaError;
     auto* info = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
     if (!info)
         error = IDBError { UnknownError, "Attempt to rename non-existant object store"_s };
 
+    startSpaceIncreaseTask(callbackID, taskSize);
     postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performRenameObjectStore, callbackID, transaction.info().identifier(), objectStoreIdentifier, newName, error));
 }
@@ -919 +1022 @@
     LOG(IndexedDB, "(db) UniqueIDBDatabase::performRenameObjectStore");
 
-    // Quota check.
-    auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
-    if (m_server->requestSpace(m_origin, taskSize) == StorageQuotaManager::Decision::Deny) {
-        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformRenameObjectStore, callbackIdentifier, IDBError(QuotaExceededError, quotaErrorMessageName("RenameObjectStore")), objectStoreIdentifier, newName));
+    if (!error.isNull()) {
+        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformRenameObjectStore, callbackIdentifier, error, objectStoreIdentifier, newName));
         return;
     }
@@ -940 +1041 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformRenameObjectStore");
 
+    finishSpaceIncreaseTask(callbackIdentifier, error.isNull());
     if (error.isNull())
         m_databaseInfo->renameObjectStore(objectStoreIdentifier, newName);
@@ -951 +1053 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::clearObjectStore");
 
+    waitForRequestSpaceCompletion(transaction, [this, &transaction, objectStoreIdentifier, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->clearObjectStoreAfetQuotaCheck(transaction, objectStoreIdentifier, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::clearObjectStoreAfetQuotaCheck(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, ErrorCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -985 +1098 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::createIndex");
 
+    auto taskSize = defaultWriteOperationCost + estimateSize(info);
+    requestSpace(transaction, taskSize, "createIndex", [this, taskSize, &transaction, info, callback = WTFMove(callback)](auto error) mutable {
+        if (!error.isNull() && *error.code() != QuotaExceededError) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->createIndexAfterQuotaCheck(taskSize, transaction, info, WTFMove(callback), error);
+    });
+}
+
+void UniqueIDBDatabase::createIndexAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction& transaction, const IDBIndexInfo& info, ErrorCallback callback, const IDBError& quotaError)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
         return;
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performCreateIndex, callbackID, transaction.info().identifier(), info));
-}
-
-void UniqueIDBDatabase::performCreateIndex(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBIndexInfo& info)
+    startSpaceIncreaseTask(callbackID, taskSize);
+    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performCreateIndex, callbackID, transaction.info().identifier(), info, quotaError));
+}
+
+void UniqueIDBDatabase::performCreateIndex(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBIndexInfo& info, const IDBError& quotaError)
 {
     ASSERT(!isMainThread());
     LOG(IndexedDB, "(db) UniqueIDBDatabase::performCreateIndex");
 
-    auto taskSize = defaultWriteOperationCost + estimateSize(info);
-    if (m_server->requestSpace(m_origin, taskSize) == StorageQuotaManager::Decision::Deny) {
-        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformCreateIndex, callbackIdentifier, IDBError(QuotaExceededError, quotaErrorMessageName("CreateIndex")), info));
+    if (!quotaError.isNull()) {
+        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformCreateIndex, callbackIdentifier, quotaError, info));
         return;
     }
@@ -1024 +1149 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformCreateIndex");
 
+    finishSpaceIncreaseTask(callbackIdentifier, error.isNull());
+
     if (error.isNull()) {
         ASSERT(m_databaseInfo);
@@ -1039 +1166 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::deleteIndex");
 
+    waitForRequestSpaceCompletion(transaction, [this, &transaction, objectStoreIdentifier, indexName, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->deleteIndexAfterQuotaCheck(transaction, objectStoreIdentifier, indexName, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::deleteIndexAfterQuotaCheck(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1092 +1230 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::renameIndex");
 
+    auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
+    requestSpace(transaction, taskSize, "renameIndex", [this, taskSize, &transaction, objectStoreIdentifier, indexIdentifier, newName, callback = WTFMove(callback)](auto error) mutable {
+        if (!error.isNull() && *error.code() != QuotaExceededError) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->renameIndexAfterQuotaCheck(taskSize, transaction, objectStoreIdentifier, indexIdentifier, newName, WTFMove(callback), error);
+    });
+}
+
+void UniqueIDBDatabase::renameIndexAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback callback, const IDBError& quotaError)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
         return;
 
-    IDBError error;
+    IDBError error = quotaError;
     auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
     if (!objectStoreInfo)
@@ -1105 +1255 @@
         error = IDBError { UnknownError, "Attempt to rename non-existant index"_s };
 
+    startSpaceIncreaseTask(callbackID, taskSize);
     postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performRenameIndex, callbackID, transaction.info().identifier(), objectStoreIdentifier, indexIdentifier, newName, error));
 }
@@ -1113 +1264 @@
     LOG(IndexedDB, "(db) UniqueIDBDatabase::performRenameIndex");
 
-    // Quota check.
-    auto taskSize = defaultWriteOperationCost + newName.sizeInBytes();
-    if (m_server->requestSpace(m_origin, taskSize) == StorageQuotaManager::Decision::Deny) {
-        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformRenameIndex, callbackIdentifier, IDBError(QuotaExceededError, quotaErrorMessageName("RenameIndex")), objectStoreIdentifier, indexIdentifier, newName));
+    if (!error.isNull()) {
+        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformRenameIndex, callbackIdentifier, error, objectStoreIdentifier, indexIdentifier, newName));
         return;
     }
@@ -1134 +1283 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformRenameIndex");
 
+    finishSpaceIncreaseTask(callbackIdentifier, error.isNull());
     if (error.isNull()) {
         auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
@@ -1147 +1297 @@
 }
 
-void UniqueIDBDatabase::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode, KeyDataCallback callback)
+void UniqueIDBDatabase::putOrAdd(UniqueIDBDatabaseTransaction& transaction, const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode, KeyDataCallback callback)
 {
     ASSERT(isMainThread());
     LOG(IndexedDB, "(main) UniqueIDBDatabase::putOrAdd");
 
+    auto taskSize = defaultWriteOperationCost + estimateSize(keyData) + estimateSize(value);
+    ASSERT(m_databaseInfo);
+    auto* objectStore = m_databaseInfo->infoForExistingObjectStore(requestData.objectStoreIdentifier());
+    if (objectStore)
+        taskSize += objectStore->indexNames().size() * taskSize;
+
+    requestSpace(transaction, taskSize, "putOrAdd", [this, taskSize, requestData, keyData, value, callback = WTFMove(callback), overwriteMode](auto error) mutable {
+        if (!error.isNull() && *error.code() != QuotaExceededError) {
+            callback(WTFMove(error), { });
+            return;
+        }
+        this->putOrAddAfterQuotaCheck(taskSize, requestData, keyData, value, overwriteMode, WTFMove(callback), error);
+    });
+}
+
+void UniqueIDBDatabase::putOrAddAfterQuotaCheck(uint64_t taskSize, const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode, KeyDataCallback callback, const IDBError& quotaError)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
         return;
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performPutOrAdd, callbackID, requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), keyData, value, overwriteMode));
-}
-
-void UniqueIDBDatabase::performPutOrAdd(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const IDBKeyData& keyData, const IDBValue& originalRecordValue, IndexedDB::ObjectStoreOverwriteMode overwriteMode)
+    startSpaceIncreaseTask(callbackID, taskSize);
+    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performPutOrAdd, callbackID, requestData.transactionIdentifier(), requestData.objectStoreIdentifier(), keyData, value, overwriteMode, quotaError));
+}
+
+void UniqueIDBDatabase::performPutOrAdd(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const IDBKeyData& keyData, const IDBValue& originalRecordValue, IndexedDB::ObjectStoreOverwriteMode overwriteMode, const IDBError& quotaError)
 {
     ASSERT(!isMainThread());
     LOG(IndexedDB, "(db) UniqueIDBDatabase::performPutOrAdd");
 
+    ASSERT(m_backingStore);
+    ASSERT(objectStoreIdentifier);
+
     IDBKeyData usedKey;
     IDBError error;
 
-    // Quota check.
-    auto taskSize = defaultWriteOperationCost + estimateSize(keyData) + estimateSize(originalRecordValue);
-    ASSERT(m_databaseInfo);
-    auto* objectStore = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
-    if (objectStore)
-        taskSize += objectStore->indexNames().size() * taskSize;
-    if (m_server->requestSpace(m_origin, taskSize) == StorageQuotaManager::Decision::Deny) {
-        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, IDBError(QuotaExceededError, quotaErrorMessageName("PutOrAdd")), usedKey));
-        return;
-    }
-
-    ASSERT(m_backingStore);
-    ASSERT(objectStoreIdentifier);
+    if (!quotaError.isNull()) {
+        postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, quotaError, usedKey));
+        return;
+    }
+
     {
         LockHolder locker(m_backingStoreLock);
@@ -1256 +1419 @@
     LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformPutOrAdd");
 
+    finishSpaceIncreaseTask(callbackIdentifier, error.isNull());
     performKeyDataCallback(callbackIdentifier, error, resultKey);
 }
 
-void UniqueIDBDatabase::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback)
+void UniqueIDBDatabase::getRecord(UniqueIDBDatabaseTransaction& transaction, const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback)
 {
     ASSERT(isMainThread());
     LOG(IndexedDB, "(main) UniqueIDBDatabase::getRecord");
 
+    waitForRequestSpaceCompletion(transaction, [this, requestData, getRecordData, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error), { });
+            return;
+        }
+        this->getRecordAfterQuotaCheck(requestData, getRecordData, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::getRecordAfterQuotaCheck(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1274 +1449 @@
 }
 
-void UniqueIDBDatabase::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback)
+void UniqueIDBDatabase::getAllRecords(UniqueIDBDatabaseTransaction& transaction, const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback)
 {
     ASSERT(isMainThread());
     LOG(IndexedDB, "(main) UniqueIDBDatabase::getAllRecords");
 
+    waitForRequestSpaceCompletion(transaction, [this, requestData, getAllRecordsData, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error), { });
+            return;
+        }
+        this->getAllRecordsAfterQuotaCheck(requestData, getAllRecordsData, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::getAllRecordsAfterQuotaCheck(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1292 +1478 @@
 
     ASSERT(m_backingStore);
+
     IDBGetResult result;
     IDBError error;
@@ -1332 +1519 @@
 
     ASSERT(m_backingStore);
+
     IDBGetAllResult result;
     IDBError error;
@@ -1350 +1538 @@
 }
 
-void UniqueIDBDatabase::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback)
+void UniqueIDBDatabase::getCount(UniqueIDBDatabaseTransaction& transaction, const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback)
 {
     ASSERT(isMainThread());
     LOG(IndexedDB, "(main) UniqueIDBDatabase::getCount");
 
+    waitForRequestSpaceCompletion(transaction, [this, requestData, range, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error), { });
+            return;
+        }
+        this->getCountAfterQuotaCheck(requestData, range, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::getCountAfterQuotaCheck(const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1387 +1586 @@
 }
 
-void UniqueIDBDatabase::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback)
+void UniqueIDBDatabase::deleteRecord(UniqueIDBDatabaseTransaction& transaction, const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback)
 {
     ASSERT(isMainThread());
     LOG(IndexedDB, "(main) UniqueIDBDatabase::deleteRecord");
 
+    waitForRequestSpaceCompletion(transaction, [this, requestData, keyRangeData, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->deleteRecordAfterQuotaCheck(requestData, keyRangeData, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::deleteRecordAfterQuotaCheck(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1420 +1630 @@
 }
 
-void UniqueIDBDatabase::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback)
+void UniqueIDBDatabase::openCursor(UniqueIDBDatabaseTransaction& transaction, const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback)
 {
     ASSERT(isMainThread());
     LOG(IndexedDB, "(main) UniqueIDBDatabase::openCursor");
 
+    waitForRequestSpaceCompletion(transaction, [this, requestData, info, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error), { });
+            return;
+        }
+        this->openCursorAfterQuotaCheck(requestData, info, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::openCursorAfterQuotaCheck(const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1454 +1675 @@
 }
 
-void UniqueIDBDatabase::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback)
+void UniqueIDBDatabase::iterateCursor(UniqueIDBDatabaseTransaction& transaction, const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback)
 {
     ASSERT(isMainThread());
     LOG(IndexedDB, "(main) UniqueIDBDatabase::iterateCursor");
 
+    waitForRequestSpaceCompletion(transaction, [this, requestData, data, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error), { });
+            return;
+        }
+        this->iterateCursorAfterQuotaCheck(requestData, data, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::iterateCursorAfterQuotaCheck(const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1536 +1768 @@
     ASSERT(transaction.databaseConnection().database() == this);
 
+    waitForRequestSpaceCompletion(transaction, [this, &transaction, callback = WTFMove(callback)](auto&& error) mutable {
+        if (!error.isNull()) {
+            callback(WTFMove(error));
+            return;
+        }
+        this->commitTransactionAfterQuotaCheck(transaction, WTFMove(callback));
+    });
+}
+
+void UniqueIDBDatabase::commitTransactionAfterQuotaCheck(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)
+{
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
     if (!callbackID)
@@ -1593 +1836 @@
 }
 
-void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)
+void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, WaitForPendingTasks waitForPendingTasks, ErrorCallback callback)
 {
     ASSERT(isMainThread());
@@ -1599 +1842 @@
 
     ASSERT(transaction.databaseConnection().database() == this);
+
+    if (waitForPendingTasks == WaitForPendingTasks::Yes) {
+        waitForRequestSpaceCompletion(transaction, [this, &transaction, callback = WTFMove(callback)](auto&& error) mutable {
+            if (!error.isNull()) {
+                callback(WTFMove(error));
+                return;
+            }
+            this->abortTransaction(transaction, WaitForPendingTasks::No, WTFMove(callback));
+        });
+        return;
+    }
 
     uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));

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

@@ -45 +45 @@
 namespace WebCore {
 
-struct ClientOrigin;
 class IDBError;
 class IDBGetAllResult;
@@ -91 +90 @@
     void deleteIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback);
     void renameIndex(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback);
-    void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback);
-    void getRecord(const IDBRequestData&, const IDBGetRecordData&, GetResultCallback);
-    void getAllRecords(const IDBRequestData&, const IDBGetAllRecordsData&, GetAllResultsCallback);
-    void getCount(const IDBRequestData&, const IDBKeyRangeData&, CountCallback);
-    void deleteRecord(const IDBRequestData&, const IDBKeyRangeData&, ErrorCallback);
-    void openCursor(const IDBRequestData&, const IDBCursorInfo&, GetResultCallback);
-    void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback);
+    void putOrAdd(UniqueIDBDatabaseTransaction&, const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback);
+    void getRecord(UniqueIDBDatabaseTransaction&, const IDBRequestData&, const IDBGetRecordData&, GetResultCallback);
+    void getAllRecords(UniqueIDBDatabaseTransaction&, const IDBRequestData&, const IDBGetAllRecordsData&, GetAllResultsCallback);
+    void getCount(UniqueIDBDatabaseTransaction&, const IDBRequestData&, const IDBKeyRangeData&, CountCallback);
+    void deleteRecord(UniqueIDBDatabaseTransaction&, const IDBRequestData&, const IDBKeyRangeData&, ErrorCallback);
+    void openCursor(UniqueIDBDatabaseTransaction&, const IDBRequestData&, const IDBCursorInfo&, GetResultCallback);
+    void iterateCursor(UniqueIDBDatabaseTransaction&, const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback);
     void commitTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
-    void abortTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
+
+    enum class WaitForPendingTasks { No, Yes };
+    void abortTransaction(UniqueIDBDatabaseTransaction&, WaitForPendingTasks, ErrorCallback);
 
     void didFinishHandlingVersionChange(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& transactionIdentifier);
@@ -140 +141 @@
     void scheduleShutdownForClose();
 
+    void createObjectStoreAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction&, const IDBObjectStoreInfo&, ErrorCallback, const IDBError&);
+    void renameObjectStoreAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String& newName, ErrorCallback, const IDBError&);
+    void createIndexAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction&, const IDBIndexInfo&, ErrorCallback, const IDBError&);
+    void renameIndexAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback, const IDBError&);
+    void putOrAddAfterQuotaCheck(uint64_t taskSize, const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback, const IDBError&);
+    void deleteRecordAfterQuotaCheck(const IDBRequestData&, const IDBKeyRangeData&, ErrorCallback);
+
+    void deleteObjectStoreAfterQuotaCheck(UniqueIDBDatabaseTransaction&, const String& objectStoreName, ErrorCallback);
+    void clearObjectStoreAfetQuotaCheck(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, ErrorCallback);
+    void deleteIndexAfterQuotaCheck(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String&, ErrorCallback);
+    void getRecordAfterQuotaCheck(const IDBRequestData&, const IDBGetRecordData&, GetResultCallback);
+    void getAllRecordsAfterQuotaCheck(const IDBRequestData&, const IDBGetAllRecordsData&, GetAllResultsCallback);
+    void getCountAfterQuotaCheck(const IDBRequestData&, const IDBKeyRangeData&, CountCallback);
+    void openCursorAfterQuotaCheck(const IDBRequestData&, const IDBCursorInfo&, GetResultCallback);
+    void iterateCursorAfterQuotaCheck(const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback);
+    void commitTransactionAfterQuotaCheck(UniqueIDBDatabaseTransaction&, ErrorCallback);
+
     // Database thread operations
     void deleteBackingStore(const IDBDatabaseIdentifier&);
-    void openBackingStore(const IDBDatabaseIdentifier&);
+    void openBackingStore(const IDBDatabaseIdentifier&, uint64_t taskIdentifier);
     void performCommitTransaction(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier);
     void performAbortTransaction(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier);
     void beginTransactionInBackingStore(const IDBTransactionInfo&);
-    void performCreateObjectStore(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBObjectStoreInfo&);
+    void performCreateObjectStore(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBObjectStoreInfo&, const IDBError&);
     void performDeleteObjectStore(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier);
     void performRenameObjectStore(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const String& newName, const IDBError&);
     void performClearObjectStore(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier);
-    void performCreateIndex(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBIndexInfo&);
+    void performCreateIndex(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBIndexInfo&, const IDBError&);
     void performDeleteIndex(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, uint64_t indexIdentifier);
     void performRenameIndex(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, const IDBError&);
-    void performPutOrAdd(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode);
+    void performPutOrAdd(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, const IDBError&);
     void performGetRecord(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const IDBKeyRangeData&, IDBGetRecordDataType);
     void performGetAllRecords(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, const IDBGetAllRecordsData&);
@@ -170 +188 @@
     // Main thread callbacks
     void didDeleteBackingStore(uint64_t deletedVersion);
-    void didOpenBackingStore(const IDBDatabaseInfo&, const IDBError&);
+    void didOpenBackingStore(const IDBDatabaseInfo&, const IDBError&, uint64_t taskIdentifier);
     void didPerformCreateObjectStore(uint64_t callbackIdentifier, const IDBError&, const IDBObjectStoreInfo&);
     void didPerformDeleteObjectStore(uint64_t callbackIdentifier, const IDBError&, uint64_t objectStoreIdentifier);
@@ -229 +247 @@
     bool isDoneWithHardClose();
 
+    void requestSpace(UniqueIDBDatabaseTransaction&, uint64_t taskSize, const char* errorMessage, CompletionHandler<void(IDBError&&)>&&);
+    void waitForRequestSpaceCompletion(UniqueIDBDatabaseTransaction&, CompletionHandler<void(IDBError&&)>&&);
+    void startSpaceIncreaseTask(uint64_t identifier, uint64_t taskSize);
+    void finishSpaceIncreaseTask(uint64_t identifier, bool isTaskSuccessful);
+
     void clearTransactionsOnConnection(UniqueIDBDatabaseConnection&);
 
@@ -289 +312 @@
     HashSet<IDBResourceIdentifier> m_cursorPrefetches;
 
+    HashMap<uint64_t, uint64_t> m_pendingSpaceIncreaseTasks;
+
     bool m_isSuspended { false };
-
-    ClientOrigin m_origin;
 };
 

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

@@ -77 +77 @@
         return;
     
-    m_database->abortTransaction(transaction, [this, protectedThis, transactionIdentifier](const IDBError&) {
+    m_database->abortTransaction(transaction, UniqueIDBDatabase::WaitForPendingTasks::No, [this, protectedThis, transactionIdentifier](const IDBError&) {
         ASSERT(m_transactionMap.contains(transactionIdentifier));
         m_transactionMap.remove(transactionIdentifier);

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

@@ -80 +80 @@
     ASSERT(database);
 
-    database->abortTransaction(*this, [this, weakThis = makeWeakPtr(*this)](auto& error) {
+    database->abortTransaction(*this, UniqueIDBDatabase::WaitForPendingTasks::Yes, [this, weakThis = makeWeakPtr(*this)](auto& error) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::abort (callback)");
         if (!weakThis)
@@ -287 +287 @@
     ASSERT(database);
     
-    database->putOrAdd(requestData, keyData, value, overwriteMode, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBKeyData& key) {
+    database->putOrAdd(*this, requestData, keyData, value, overwriteMode, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBKeyData& key) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::putOrAdd (callback)");
         if (!weakThis)
@@ -308 +308 @@
     ASSERT(database);
     
-    database->getRecord(requestData, getRecordData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetResult& result) {
+    database->getRecord(*this, requestData, getRecordData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetResult& result) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::getRecord (callback)");
         if (!weakThis)
@@ -329 +329 @@
     ASSERT(database);
     
-    database->getAllRecords(requestData, getAllRecordsData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetAllResult& result) {
+    database->getAllRecords(*this, requestData, getAllRecordsData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetAllResult& result) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::getAllRecords (callback)");
         if (!weakThis)
@@ -350 +350 @@
     ASSERT(database);
     
-    database->getCount(requestData, keyRangeData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, uint64_t count) {
+    database->getCount(*this, requestData, keyRangeData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, uint64_t count) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::getCount (callback)");
         if (!weakThis)
@@ -371 +371 @@
     ASSERT(database);
     
-    database->deleteRecord(requestData, keyRangeData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error) {
+    database->deleteRecord(*this, requestData, keyRangeData, [this, weakThis = makeWeakPtr(*this), requestData](auto& error) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::deleteRecord (callback)");
         if (!weakThis)
@@ -392 +392 @@
     ASSERT(database);
     
-    database->openCursor(requestData, info, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetResult& result) {
+    database->openCursor(*this, requestData, info, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetResult& result) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::openCursor (callback)");
         if (!weakThis)
@@ -413 +413 @@
     ASSERT(database);
     
-    database->iterateCursor(requestData, data, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetResult& result) {
+    database->iterateCursor(*this, requestData, data, [this, weakThis = makeWeakPtr(*this), requestData](auto& error, const IDBGetResult& result) {
         LOG(IndexedDB, "UniqueIDBDatabaseTransaction::iterateCursor (callback)");
         if (!weakThis)

trunk/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp

@@ -65 +65 @@
 {
     return m_quotaManagers.ensure(origin, [] {
-        return StorageQuotaManager::create(StorageQuotaManager::defaultQuota(), [] {
-            return 0;
-        }, [](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {
+        return makeUnique<StorageQuotaManager>(StorageQuotaManager::defaultQuota(), [](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {
             callback(quota + currentSpace + spaceIncrease);
         });
@@ -73 +71 @@
 }
 
-static inline IDBServer::IDBServer::StorageQuotaManagerSpaceRequester storageQuotaManagerSpaceRequester(InProcessIDBServer& server)
-{
-    return [server = &server, weakServer = makeWeakPtr(server)](const ClientOrigin& origin, uint64_t spaceRequested) mutable {
-        auto* storageQuotaManager = weakServer ? server->quotaManager(origin) : nullptr;
-        return storageQuotaManager ? storageQuotaManager->requestSpaceOnBackgroundThread(spaceRequested) : StorageQuotaManager::Decision::Deny;
+static inline IDBServer::IDBServer::QuotaManagerGetter storageQuotaManagerGetter(InProcessIDBServer& server)
+{
+    return [weakServer = makeWeakPtr(server)](PAL::SessionID, const auto& origin) {
+        return weakServer ? weakServer->quotaManager(origin) : nullptr;
     };
 }
 
 InProcessIDBServer::InProcessIDBServer(PAL::SessionID sessionID)
-    : m_server(IDBServer::IDBServer::create(sessionID, storageQuotaManagerSpaceRequester(*this)))
-{
-    ASSERT(isMainThread());
+    : m_server(IDBServer::IDBServer::create(sessionID, storageQuotaManagerGetter(*this)))
+{
     relaxAdoptionRequirement();
     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);
@@ -91 +87 @@
 
 InProcessIDBServer::InProcessIDBServer(PAL::SessionID sessionID, const String& databaseDirectoryPath)
-    : m_server(IDBServer::IDBServer::create(sessionID, databaseDirectoryPath, storageQuotaManagerSpaceRequester(*this)))
-{
-    ASSERT(isMainThread());
+    : m_server(IDBServer::IDBServer::create(sessionID, databaseDirectoryPath, storageQuotaManagerGetter(*this)))
+{
     relaxAdoptionRequirement();
     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);

trunk/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.h

@@ -65 +65 @@
     IDBServer::IDBConnectionToClient& connectionToClient() const;
     IDBServer::IDBServer& server() { return m_server.get(); }
+
     IDBServer::IDBServer& idbServer() { return m_server.get(); }
 
@@ -135 +136 @@
     RefPtr<IDBServer::IDBConnectionToClient> m_connectionToClient;
 
-    HashMap<ClientOrigin, RefPtr<StorageQuotaManager>> m_quotaManagers;
+    HashMap<ClientOrigin, std::unique_ptr<StorageQuotaManager>> m_quotaManagers;
 };
 

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

@@ -1130 +1130 @@
                 41D41C672256874F00697942 /* ServiceWorkerInternals.mm in Sources */ = {isa = PBXBuildFile; fileRef = 41D41C652256859200697942 /* ServiceWorkerInternals.mm */; };
                 41DE7C7C222DA14300532B65 /* StorageQuotaManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 41DE7C7B222DA13E00532B65 /* StorageQuotaManager.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                41DE7C7D222DA14800532B65 /* StorageQuotaUser.h in Headers */ = {isa = PBXBuildFile; fileRef = 41DE7C78222DA13C00532B65 /* StorageQuotaUser.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 41DEFCB61E56C1BD000D9E5F /* JSDOMMapLike.h in Headers */ = {isa = PBXBuildFile; fileRef = 41DEFCB41E56C1B9000D9E5F /* JSDOMMapLike.h */; };
                 41E1B1D10FF5986900576B3B /* AbstractWorker.h in Headers */ = {isa = PBXBuildFile; fileRef = 41E1B1CB0FF5986900576B3B /* AbstractWorker.h */; };
@@ -7465 +7466 @@
                 41D41C652256859200697942 /* ServiceWorkerInternals.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ServiceWorkerInternals.mm; sourceTree = "<group>"; };
                 41D51BB21E4E2E8100131A5B /* LibWebRTCAudioFormat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LibWebRTCAudioFormat.h; path = libwebrtc/LibWebRTCAudioFormat.h; sourceTree = "<group>"; };
+                41DE7C78222DA13C00532B65 /* StorageQuotaUser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageQuotaUser.h; sourceTree = "<group>"; };
                 41DE7C7A222DA13D00532B65 /* StorageQuotaManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageQuotaManager.cpp; sourceTree = "<group>"; };
                 41DE7C7B222DA13E00532B65 /* StorageQuotaManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageQuotaManager.h; sourceTree = "<group>"; };
@@ -17100 +17102 @@
                                 41DE7C7A222DA13D00532B65 /* StorageQuotaManager.cpp */,
                                 41DE7C7B222DA13E00532B65 /* StorageQuotaManager.h */,
+                                41DE7C78222DA13C00532B65 /* StorageQuotaUser.h */,
                                 5166D3CC1E8ED41100AD62E3 /* StorageType.h */,
                         );
@@ -32217 +32220 @@
                                 1A37636C1A2E68BB009A7EE2 /* StorageNamespaceProvider.h in Headers */,
                                 41DE7C7C222DA14300532B65 /* StorageQuotaManager.h in Headers */,
+                                41DE7C7D222DA14800532B65 /* StorageQuotaUser.h in Headers */,
                                 5C9EF2F321F06190003BDC56 /* StorageSessionProvider.h in Headers */,
                                 5166D3CD1E8ED48F00AD62E3 /* StorageType.h in Headers */,

trunk/Source/WebCore/storage/StorageQuotaManager.cpp

@@ -28 +28 @@
 
 #include "Logging.h"
-#include <wtf/Ref.h>
-#include <wtf/RefCounted.h>
-#include <wtf/threads/BinarySemaphore.h>
+#include "StorageQuotaUser.h"
 
 namespace WebCore {
 
-Ref<StorageQuotaManager> StorageQuotaManager::create(uint64_t quota, UsageGetter&& usageGetter, QuotaIncreaseRequester&& quotaIncreaseRequester)
-{
-    return adoptRef(*new StorageQuotaManager(quota, WTFMove(usageGetter), WTFMove(quotaIncreaseRequester)));
-}
-
-StorageQuotaManager::StorageQuotaManager(uint64_t quota, UsageGetter&& usageGetter, QuotaIncreaseRequester&& quotaIncreaseRequester)
-    : m_quota(quota)
-    , m_usageGetter(WTFMove(usageGetter))
-    , m_quotaIncreaseRequester(WTFMove(quotaIncreaseRequester))
-    , m_workQueue(WorkQueue::create("StorageQuotaManager Background Queue", WorkQueue::Type::Serial))
-    , m_initialQuota(quota)
-{
-}
-
-void StorageQuotaManager::requestSpaceOnMainThread(uint64_t spaceRequested, RequestCallback&& callback)
-{
-    ASSERT(isMainThread());
-
-    // Fast path.
-    if (m_quotaCountDownLock.tryLock()) {
-        if (tryGrantRequest(spaceRequested)) {
-            m_quotaCountDownLock.unlock();
-            callback(Decision::Grant);
-            return;
+StorageQuotaManager::~StorageQuotaManager()
+{
+    while (!m_pendingRequests.isEmpty())
+        m_pendingRequests.takeFirst().callback(Decision::Deny);
+}
+
+uint64_t StorageQuotaManager::spaceUsage() const
+{
+    uint64_t usage = 0;
+    for (auto& user : m_users)
+        usage += user->spaceUsed();
+    return usage;
+}
+
+void StorageQuotaManager::updateQuotaBasedOnSpaceUsage()
+{
+    if (!m_quota)
+        return;
+
+    auto defaultQuotaStep = m_quota / 10;
+    m_quota = std::max(m_quota, defaultQuotaStep * ((spaceUsage() / defaultQuotaStep) + 1));
+}
+
+void StorageQuotaManager::initializeUsersIfNeeded()
+{
+    if (m_pendingInitializationUsers.isEmpty())
+        return;
+
+    Vector<StorageQuotaUser*> usersToInitialize;
+    for (auto& keyValue : m_pendingInitializationUsers) {
+        if (keyValue.value == WhenInitializedCalled::No) {
+            keyValue.value = WhenInitializedCalled::Yes;
+            usersToInitialize.append(keyValue.key);
         }
-        m_quotaCountDownLock.unlock();
-    }
-
-    m_workQueue->dispatch([this, protectedThis = makeRef(*this), spaceRequested, callback = WTFMove(callback)]() mutable {
-        auto decision = requestSpaceOnBackgroundThread(spaceRequested);
-        callOnMainThread([callback = WTFMove(callback), decision]() mutable {
-            callback(decision);
+    }
+    for (auto* user : usersToInitialize) {
+        if (m_pendingInitializationUsers.contains(user))
+            askUserToInitialize(*user);
+    }
+}
+
+void StorageQuotaManager::askUserToInitialize(StorageQuotaUser& user)
+{
+    user.whenInitialized([this, &user, weakThis = makeWeakPtr(this)]() {
+        if (!weakThis)
+            return;
+
+        if (m_pendingInitializationUsers.remove(&user))
+            m_users.add(&user);
+
+        if (!m_pendingInitializationUsers.isEmpty())
+            return;
+
+        // Make sure quota is set before handling first request.
+        if (m_state == State::Uninitialized) {
+            updateQuotaBasedOnSpaceUsage();
+            m_state = State::MakingDecisionForRequest;
+        }
+
+        processPendingRequests({ });
+    });
+}
+
+void StorageQuotaManager::addUser(StorageQuotaUser& user)
+{
+    ASSERT(!m_pendingInitializationUsers.contains(&user));
+    ASSERT(!m_users.contains(&user));
+    m_pendingInitializationUsers.add(&user, WhenInitializedCalled::No);
+
+    if (!m_pendingRequests.isEmpty())
+        askUserToInitialize(user);
+}
+
+bool StorageQuotaManager::shouldAskForMoreSpace(uint64_t spaceIncrease) const
+{
+    if (!spaceIncrease)
+        return false;
+
+    return spaceUsage() + spaceIncrease > m_quota;
+}
+
+void StorageQuotaManager::removeUser(StorageQuotaUser& user)
+{
+    ASSERT(m_users.contains(&user) || m_pendingInitializationUsers.contains(&user));
+    m_users.remove(&user);
+    if (m_pendingInitializationUsers.remove(&user) && m_pendingInitializationUsers.isEmpty()) {
+        // When being cleared, quota users may remove themselves and add themselves to trigger reinitialization.
+        // Let's wait for addUser to be called before processing pending requests.
+        callOnMainThread([this, weakThis = makeWeakPtr(this)] {
+            if (!weakThis)
+                return;
+
+            if (m_pendingInitializationUsers.isEmpty())
+                this->processPendingRequests({ });
         });
+    }
+}
+
+void StorageQuotaManager::requestSpace(uint64_t spaceIncrease, RequestCallback&& callback)
+{
+    if (!m_pendingRequests.isEmpty()) {
+        m_pendingRequests.append({ spaceIncrease, WTFMove(callback) });
+        return;
+    }
+
+    if (!spaceIncrease) {
+        callback(Decision::Grant);
+        return;
+    }
+
+    initializeUsersIfNeeded();
+
+    if (!m_pendingInitializationUsers.isEmpty()) {
+        m_pendingRequests.append({ spaceIncrease, WTFMove(callback) });
+        return;
+    }
+
+    if (shouldAskForMoreSpace(spaceIncrease)) {
+        m_pendingRequests.append({ spaceIncrease, WTFMove(callback) });
+
+        // Try processing request again after making sure usage is accurate.
+        m_state = State::ComputingSpaceUsed;
+        for (auto& user : copyToVector(m_users))
+            user->computeSpaceUsed();
+
+        if (!m_pendingInitializationUsers.isEmpty())
+            return;
+
+        m_state = State::AskingForMoreSpace;
+        askForMoreSpace(spaceIncrease);
+        return;
+    }
+
+    m_state = State::MakingDecisionForRequest;
+    callback(Decision::Grant);
+}
+
+void StorageQuotaManager::askForMoreSpace(uint64_t spaceIncrease)
+{
+    ASSERT(shouldAskForMoreSpace(spaceIncrease));
+    ASSERT(m_state == State::AskingForMoreSpace);
+
+    RELEASE_LOG(Storage, "%p - StorageQuotaManager::askForMoreSpace %" PRIu64, this, spaceIncrease);
+    m_state = State::WaitingForSpaceIncreaseResponse;
+    m_spaceIncreaseRequester(m_quota, spaceUsage(), spaceIncrease, [this, weakThis = makeWeakPtr(*this)](Optional<uint64_t> newQuota) {
+        if (!weakThis)
+            return;
+
+        RELEASE_LOG(Storage, "%p - StorageQuotaManager::askForMoreSpace received response %" PRIu64, this, newQuota ? *newQuota : 0);
+
+        m_state = State::AskingForMoreSpace;
+        processPendingRequests(newQuota);
     });
 }
 
-StorageQuotaManager::Decision StorageQuotaManager::requestSpaceOnBackgroundThread(uint64_t spaceRequested)
-{
-    ASSERT(!isMainThread());
-
-    LockHolder locker(m_quotaCountDownLock);
-
-    if (tryGrantRequest(spaceRequested))
-        return Decision::Grant;
-
-    m_usage = m_usageGetter();
-    updateQuotaBasedOnUsage();
-    m_quotaCountDown = m_usage < m_quota ? m_quota - m_usage : 0;
-    if (tryGrantRequest(spaceRequested))
-        return Decision::Grant;
-
-    // Block this thread until getting decsion for quota increase.
-    BinarySemaphore semaphore;
-    callOnMainThread([this, protectedThis = makeRef(*this), spaceRequested, &semaphore]() mutable {
-        RELEASE_LOG(Storage, "%p - StorageQuotaManager asks for quota increase %" PRIu64, this, spaceRequested);
-        m_quotaIncreaseRequester(m_quota, m_usage, spaceRequested, [this, protectedThis = WTFMove(protectedThis), &semaphore](Optional<uint64_t> newQuota) mutable {
-            RELEASE_LOG(Storage, "%p - StorageQuotaManager receives quota increase response %" PRIu64, this, newQuota ? *newQuota : 0);
-            ASSERT(isMainThread());
-
-            if (newQuota)
-                m_quota = *newQuota;
-
-            semaphore.signal();
-        });
-    });
-
-    semaphore.wait();
-
-    m_usage = m_usageGetter();
-    m_quotaCountDown = m_usage < m_quota ? m_quota - m_usage : 0;
-    return tryGrantRequest(spaceRequested) ? Decision::Grant : Decision::Deny;
-}
-
-bool StorageQuotaManager::tryGrantRequest(uint64_t spaceRequested)
-{
-    ASSERT(m_quotaCountDownLock.isLocked());
-    if (spaceRequested <= m_quotaCountDown) {
-        m_quotaCountDown -= spaceRequested;
-        return true;
-    }
-    return false;
-}
-    
-void StorageQuotaManager::updateQuotaBasedOnUsage()
-{
-    // When StorageQuotaManager is used for the first time, we want to make sure its initial quota is bigger than current disk usage,
-    // based on the assumption that the quota was increased to at least the disk usage under user's permission before.
-    ASSERT(m_quotaCountDownLock.isLocked());
-    if (!m_quotaUpdatedBasedOnUsage) {
-        m_quotaUpdatedBasedOnUsage = true;
-        auto defaultQuotaStep = m_quota / 10;
-        m_quota = std::max(m_quota, defaultQuotaStep * ((m_usage / defaultQuotaStep) + 1));
-    }
-}
-
-void StorageQuotaManager::resetQuotaUpdatedBasedOnUsageForTesting()
-{
-    LockHolder locker(m_quotaCountDownLock);
-    m_quota = m_initialQuota;
-    m_quotaCountDown = 0;
-    m_quotaUpdatedBasedOnUsage = false;
-}
-
-void StorageQuotaManager::resetQuotaForTesting()
-{
-    LockHolder locker(m_quotaCountDownLock);
-    m_quota = m_initialQuota;
-    m_quotaCountDown = 0;
+void StorageQuotaManager::processPendingRequests(Optional<uint64_t> newQuota)
+{
+    if (m_pendingRequests.isEmpty())
+        return;
+
+    if (newQuota)
+        m_quota = *newQuota;
+
+    if (m_state == State::WaitingForSpaceIncreaseResponse)
+        return;
+
+    if (!m_pendingInitializationUsers.isEmpty())
+        return;
+
+    if (m_state == State::AskingForMoreSpace) {
+        auto request = m_pendingRequests.takeFirst();
+        bool shouldAllowRequest = !shouldAskForMoreSpace(request.spaceIncrease);
+
+        RELEASE_LOG(Storage, "%p - StorageQuotaManager::processPendingRequests first request decision is %d", this, shouldAllowRequest);
+
+        m_state = State::MakingDecisionForRequest;
+        request.callback(shouldAllowRequest ? Decision::Grant : Decision::Deny);
+    }
+
+    while (!m_pendingRequests.isEmpty()) {
+        auto& request = m_pendingRequests.first();
+
+        if (shouldAskForMoreSpace(request.spaceIncrease)) {
+            if (m_state == State::MakingDecisionForRequest) {
+                m_state = State::ComputingSpaceUsed;
+                for (auto& user : copyToVector(m_users))
+                    user->computeSpaceUsed();
+
+                if (!m_pendingInitializationUsers.isEmpty())
+                    return;
+            }
+
+            m_state = State::AskingForMoreSpace;
+            uint64_t spaceIncrease = 0;
+            for (auto& pendingRequest : m_pendingRequests)
+                spaceIncrease += pendingRequest.spaceIncrease;
+            askForMoreSpace(spaceIncrease);
+            return;
+        }
+
+        m_state = State::MakingDecisionForRequest;
+        m_pendingRequests.takeFirst().callback(Decision::Grant);
+    }
 }
 

trunk/Source/WebCore/storage/StorageQuotaManager.h

@@ -26 +26 @@
 #pragma once
 
+#include "ClientOrigin.h"
 #include <wtf/CompletionHandler.h>
 #include <wtf/Deque.h>
@@ -31 +32 @@
 #include <wtf/HashSet.h>
 #include <wtf/WeakPtr.h>
-#include <wtf/WorkQueue.h>
 
 namespace WebCore {
 
-class StorageQuotaManager : public ThreadSafeRefCounted<StorageQuotaManager>, public CanMakeWeakPtr<StorageQuotaManager> {
+class StorageQuotaUser;
+
+class StorageQuotaManager : public CanMakeWeakPtr<StorageQuotaManager> {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    using UsageGetter = Function<uint64_t()>;
-    using QuotaIncreaseRequester = Function<void(uint64_t currentQuota, uint64_t currentUsage, uint64_t requestedIncrease, CompletionHandler<void(Optional<uint64_t>)>&&)>;
-    WEBCORE_EXPORT static Ref<StorageQuotaManager> create(uint64_t quota, UsageGetter&&, QuotaIncreaseRequester&&);
+    using SpaceIncreaseRequester = WTF::Function<void(uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, CompletionHandler<void(Optional<uint64_t>)>&&)>;
+    StorageQuotaManager(uint64_t quota, SpaceIncreaseRequester&& spaceIncreaseRequester)
+        : m_quota(quota)
+        , m_spaceIncreaseRequester(WTFMove(spaceIncreaseRequester))
+    {
+    }
+    WEBCORE_EXPORT ~StorageQuotaManager();
 
     static constexpr uint64_t defaultThirdPartyQuotaFromPerOriginQuota(uint64_t quota) { return quota / 10; }
+
     static constexpr uint64_t defaultQuota() { return 1000 * MB; }
     static constexpr uint64_t defaultThirdPartyQuota() { return defaultThirdPartyQuotaFromPerOriginQuota(defaultQuota()); }
 
+    WEBCORE_EXPORT void addUser(StorageQuotaUser&);
+    WEBCORE_EXPORT void removeUser(StorageQuotaUser&);
+
     enum class Decision { Deny, Grant };
     using RequestCallback = CompletionHandler<void(Decision)>;
-    WEBCORE_EXPORT void requestSpaceOnMainThread(uint64_t, RequestCallback&&);
-    WEBCORE_EXPORT Decision requestSpaceOnBackgroundThread(uint64_t);
+    WEBCORE_EXPORT void requestSpace(uint64_t, RequestCallback&&);
+    void resetQuota(uint64_t newQuota) { m_quota = newQuota; }
 
-    WEBCORE_EXPORT void resetQuotaUpdatedBasedOnUsageForTesting();
-    WEBCORE_EXPORT void resetQuotaForTesting();
+    WEBCORE_EXPORT void updateQuotaBasedOnSpaceUsage();
+
+    enum class State {
+        Uninitialized,
+        ComputingSpaceUsed,
+        WaitingForSpaceIncreaseResponse,
+        AskingForMoreSpace,
+        MakingDecisionForRequest,
+    };
+    State state() const { return m_state; }
 
 private:
-    StorageQuotaManager(uint64_t quota, UsageGetter&&, QuotaIncreaseRequester&&);
-    bool tryGrantRequest(uint64_t);
+    uint64_t spaceUsage() const;
+    bool shouldAskForMoreSpace(uint64_t spaceIncrease) const;
+    void askForMoreSpace(uint64_t spaceIncrease);
 
-    void updateQuotaBasedOnUsage();
+    void initializeUsersIfNeeded();
+    void askUserToInitialize(StorageQuotaUser&);
 
-    Lock m_quotaCountDownLock;
-    uint64_t m_quotaCountDown { 0 };
+    void processPendingRequests(Optional<uint64_t>);
+
     uint64_t m_quota { 0 };
-    uint64_t m_usage { 0 };
 
-    UsageGetter m_usageGetter;
-    QuotaIncreaseRequester m_quotaIncreaseRequester;
+    SpaceIncreaseRequester m_spaceIncreaseRequester;
 
-    Ref<WorkQueue> m_workQueue;
+    enum class WhenInitializedCalled { No, Yes };
+    HashMap<StorageQuotaUser*, WhenInitializedCalled> m_pendingInitializationUsers;
+    HashSet<StorageQuotaUser*> m_users;
 
-    bool m_quotaUpdatedBasedOnUsage { false };
+    struct PendingRequest {
+        uint64_t spaceIncrease;
+        RequestCallback callback;
+    };
+    Deque<PendingRequest> m_pendingRequests;
 
-    // Test only.
-    uint64_t m_initialQuota { 0 };
+    State m_state { State::Uninitialized };
 };
 

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2019-11-23  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r252805.
+        https://bugs.webkit.org/show_bug.cgi?id=204553
+
+        Caused test failures and ASan crashes (Requested by ap on
+        #webkit).
+
+        Reverted changeset:
+
+        "Cross-thread version StorageQuotaManager"
+        https://bugs.webkit.org/show_bug.cgi?id=203971
+        https://trac.webkit.org/changeset/252805
+
 2019-11-22  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

@@ -66 +66 @@
 #include "WebsiteDataStoreParameters.h"
 #include "WebsiteDataType.h"
-#include <WebCore/ClientOrigin.h>
 #include <WebCore/CookieJar.h>
 #include <WebCore/DNS.h>
@@ -318 +317 @@
     setSession(sessionID, NetworkSession::create(*this, WTFMove(parameters.defaultDataStoreParameters.networkSessionParameters)));
 
-    SandboxExtension::consumePermanently(parameters.defaultDataStoreParameters.cacheStorageDirectoryExtensionHandle);
-    addSessionStorageQuotaManager(sessionID, parameters.defaultDataStoreParameters.perOriginStorageQuota, parameters.defaultDataStoreParameters.perThirdPartyOriginStorageQuota, parameters.defaultDataStoreParameters.cacheStorageDirectory, parameters.defaultDataStoreParameters.cacheStorageDirectoryExtensionHandle);
-
 #if ENABLE(INDEXED_DATABASE)
     addIndexedDatabaseSession(sessionID, parameters.defaultDataStoreParameters.indexedDatabaseDirectory, parameters.defaultDataStoreParameters.indexedDatabaseDirectoryExtensionHandle);
@@ -331 +327 @@
     }
 #endif
+    initializeStorageQuota(parameters.defaultDataStoreParameters);
 
     m_storageManagerSet->add(sessionID, parameters.defaultDataStoreParameters.localStorageDirectory, parameters.defaultDataStoreParameters.localStorageDirectoryExtensionHandle);
@@ -438 +435 @@
 void NetworkProcess::addWebsiteDataStore(WebsiteDataStoreParameters&& parameters)
 {
-    auto sessionID = parameters.networkSessionParameters.sessionID;
-
-    addSessionStorageQuotaManager(sessionID, parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota, parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);
-
 #if ENABLE(INDEXED_DATABASE)
-    addIndexedDatabaseSession(sessionID, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
+    addIndexedDatabaseSession(parameters.networkSessionParameters.sessionID, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
 #endif
 
 #if ENABLE(SERVICE_WORKER)
     if (parentProcessHasServiceWorkerEntitlement())
-        addServiceWorkerSession(sessionID, parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
-#endif
-
-    m_storageManagerSet->add(sessionID, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle);
+        addServiceWorkerSession(parameters.networkSessionParameters.sessionID, parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
+#endif
+
+    m_storageManagerSet->add(parameters.networkSessionParameters.sessionID, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle);
+
+    initializeStorageQuota(parameters);
 
     RemoteNetworkingContext::ensureWebsiteDataStoreSession(*this, WTFMove(parameters));
 }
 
-void NetworkProcess::addSessionStorageQuotaManager(PAL::SessionID sessionID, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota, const String& cacheRootPath, SandboxExtension::Handle& cacheRootPathHandle)
-{
-    LockHolder locker(m_sessionStorageQuotaManagersLock);
-    auto [iter, isNewEntry] = m_sessionStorageQuotaManagers.ensure(sessionID, [defaultQuota, defaultThirdPartyQuota, &cacheRootPath] {
-        return makeUnique<SessionStorageQuotaManager>(cacheRootPath, defaultQuota, defaultThirdPartyQuota);
-    });
-    if (isNewEntry)
-        SandboxExtension::consumePermanently(cacheRootPathHandle);
-}
-
-void NetworkProcess::removeSessionStorageQuotaManager(PAL::SessionID sessionID)
-{
-    LockHolder locker(m_sessionStorageQuotaManagersLock);
-    ASSERT(m_sessionStorageQuotaManagers.contains(sessionID));
-    m_sessionStorageQuotaManagers.remove(sessionID);
+void NetworkProcess::initializeStorageQuota(const WebsiteDataStoreParameters& parameters)
+{
+    auto& managers =  m_storageQuotaManagers.ensure(parameters.networkSessionParameters.sessionID, [] {
+        return StorageQuotaManagers { };
+    }).iterator->value;
+    managers.setDefaultQuotas(parameters.perOriginStorageQuota, parameters.perThirdPartyOriginStorageQuota);
 }
 
@@ -591 +577 @@
 
     m_storageManagerSet->remove(sessionID);
+
+    m_storageQuotaManagers.remove(sessionID);
 }
 
@@ -1481 +1469 @@
         clearDiskCache(modifiedSince, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
 
+    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) || websiteDataTypes.contains(WebsiteDataType::DOMCache))
+        clearStorageQuota(sessionID);
+
     if (websiteDataTypes.contains(WebsiteDataType::AdClickAttributions)) {
         if (auto* networkSession = this->networkSession(sessionID))
@@ -1573 +1564 @@
         WebCore::CredentialStorage::removeSessionCredentialsWithOrigins(originDatas);
     }
+
+    // FIXME: Implement storage quota clearing for these origins.
+}
+
+void NetworkProcess::clearStorageQuota(PAL::SessionID sessionID)
+{
+    auto iterator = m_storageQuotaManagers.find(sessionID);
+    if (iterator == m_storageQuotaManagers.end())
+        return;
+
+    auto& managers = iterator->value;
+    for (auto& manager : managers.managersPerOrigin())
+        manager.value->resetQuota(managers.defaultQuota(manager.key));
 }
 
@@ -2214 +2218 @@
     }
 
-    return IDBServer::IDBServer::create(sessionID, path, [this, weakThis = makeWeakPtr(this), sessionID](const auto& origin, uint64_t spaceRequested) {
-        RefPtr<StorageQuotaManager> storageQuotaManager = weakThis ? this->storageQuotaManager(sessionID, origin) : nullptr;
-        return storageQuotaManager ? storageQuotaManager->requestSpaceOnBackgroundThread(spaceRequested) : StorageQuotaManager::Decision::Deny;
+    return IDBServer::IDBServer::create(sessionID, path, [this, weakThis = makeWeakPtr(this)](PAL::SessionID sessionID, const auto& origin) -> StorageQuotaManager* {
+        if (!weakThis)
+            return nullptr;
+        return &this->storageQuotaManager(sessionID, origin);
     });
 }
@@ -2303 +2308 @@
         if (!indexedDatabaseDirectory.isEmpty())
             postStorageTask(createCrossThreadTask(*this, &NetworkProcess::ensurePathExists, indexedDatabaseDirectory));
-        setSessionStorageQuotaManagerIDBRootPath(sessionID, indexedDatabaseDirectory);
-    }
-}
-
-void NetworkProcess::setSessionStorageQuotaManagerIDBRootPath(PAL::SessionID sessionID, const String& idbRootPath)
-{
-    LockHolder locker(m_sessionStorageQuotaManagersLock);
-    auto* sessionStorageQuotaManager = m_sessionStorageQuotaManagers.get(sessionID);
-    ASSERT(sessionStorageQuotaManager);
-    sessionStorageQuotaManager->setIDBRootPath(idbRootPath);
-}
-
+    }
+}
 #endif // ENABLE(INDEXED_DATABASE)
 
@@ -2331 +2326 @@
 void NetworkProcess::updateQuotaBasedOnSpaceUsageForTesting(PAL::SessionID sessionID, const ClientOrigin& origin)
 {
-    auto storageQuotaManager = this->storageQuotaManager(sessionID, origin);
-    storageQuotaManager->resetQuotaUpdatedBasedOnUsageForTesting();
-}
-
-void NetworkProcess::resetQuota(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
-{
-    LockHolder locker(m_sessionStorageQuotaManagersLock);
-    if (auto* sessionStorageQuotaManager = m_sessionStorageQuotaManagers.get(sessionID)) {
-        for (auto storageQuotaManager : sessionStorageQuotaManager->existingStorageQuotaManagers())
-            storageQuotaManager->resetQuotaForTesting();
-    }
-    completionHandler();
+    auto& manager = storageQuotaManager(sessionID, origin);
+    manager.resetQuota(m_storageQuotaManagers.find(sessionID)->value.defaultQuota(origin));
+    manager.updateQuotaBasedOnSpaceUsage();
 }
 
@@ -2419 +2405 @@
 }
 
-RefPtr<StorageQuotaManager> NetworkProcess::storageQuotaManager(PAL::SessionID sessionID, const ClientOrigin& origin)
-{
-    LockHolder locker(m_sessionStorageQuotaManagersLock);
-    auto* sessionStorageQuotaManager = m_sessionStorageQuotaManagers.get(sessionID);
-    if (!sessionStorageQuotaManager)
-        return nullptr;
-
-    String idbRootPath;
-#if ENABLE(INDEXED_DATABASE)
-    idbRootPath = sessionStorageQuotaManager->idbRootPath();
-#endif
-    StorageQuotaManager::UsageGetter usageGetter = [cacheRootPath = sessionStorageQuotaManager->cacheRootPath().isolatedCopy(), idbRootPath = idbRootPath.isolatedCopy(), origin = origin.isolatedCopy()]() {
-        ASSERT(!isMainThread());    
-
-        uint64_t usage = CacheStorage::Engine::diskUsage(cacheRootPath, origin);
-#if ENABLE(INDEXED_DATABASE)
-        usage += IDBServer::IDBServer::diskUsage(idbRootPath, origin);
-#endif
-
-        return usage;
-    };
-    StorageQuotaManager::QuotaIncreaseRequester quotaIncreaseRequester = [this, weakThis = makeWeakPtr(*this), sessionID, origin] (uint64_t currentQuota, uint64_t currentSpace, uint64_t requestedIncrease, auto&& callback) {
-        ASSERT(isMainThread());
+class QuotaUserInitializer final : public WebCore::StorageQuotaUser {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    explicit QuotaUserInitializer(StorageQuotaManager& manager)
+        : m_manager(makeWeakPtr(manager))
+    {
+        manager.addUser(*this);
+    }
+
+    ~QuotaUserInitializer()
+    {
+        if (m_manager)
+            m_manager->removeUser(*this);
+        if (m_callback)
+            m_callback();
+    }
+
+private:
+    // StorageQuotaUser API.
+    uint64_t spaceUsed() const final
+    {
+        ASSERT_NOT_REACHED();
+        return 0;
+    }
+
+    void whenInitialized(CompletionHandler<void()>&& callback) final
+    {
+        m_callback = WTFMove(callback);
+    }
+
+    WeakPtr<StorageQuotaManager> m_manager;
+    CompletionHandler<void()> m_callback;
+};
+
+void NetworkProcess::initializeQuotaUsers(StorageQuotaManager& manager, PAL::SessionID sessionID, const ClientOrigin& origin)
+{
+    RunLoop::main().dispatch([this, weakThis = makeWeakPtr(this), sessionID, origin, user = makeUnique<QuotaUserInitializer>(manager)]() mutable {
         if (!weakThis)
-            callback({ });
-        requestStorageSpace(sessionID, origin, currentQuota, currentSpace, requestedIncrease, WTFMove(callback));
-    };
-
-    return sessionStorageQuotaManager->ensureOriginStorageQuotaManager(origin, sessionStorageQuotaManager->defaultQuota(origin), WTFMove(usageGetter), WTFMove(quotaIncreaseRequester)).ptr();
+            return;
+        this->idbServer(sessionID).initializeQuotaUser(origin);
+        CacheStorage::Engine::initializeQuotaUser(*this, sessionID, origin, [user = WTFMove(user)] { });
+    });
+}
+
+StorageQuotaManager& NetworkProcess::storageQuotaManager(PAL::SessionID sessionID, const ClientOrigin& origin)
+{
+    auto& storageQuotaManagers = m_storageQuotaManagers.ensure(sessionID, [] {
+        return StorageQuotaManagers { };
+    }).iterator->value;
+    return *storageQuotaManagers.managersPerOrigin().ensure(origin, [this, &storageQuotaManagers, sessionID, &origin] {
+        auto manager = makeUnique<StorageQuotaManager>(storageQuotaManagers.defaultQuota(origin), [this, sessionID, origin](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {
+            this->requestStorageSpace(sessionID, origin, quota, currentSpace, spaceIncrease, WTFMove(callback));
+        });
+        initializeQuotaUsers(*manager, sessionID, origin);
+        return manager;
+    }).iterator->value;
 }
 

trunk/Source/WebKit/NetworkProcess/NetworkProcess.h

@@ -285 +285 @@
 
     void updateQuotaBasedOnSpaceUsageForTesting(PAL::SessionID, const WebCore::ClientOrigin&);
-    void resetQuota(PAL::SessionID, CompletionHandler<void()>&&);
 
 #if ENABLE(SANDBOX_EXTENSIONS)
@@ -329 +328 @@
     void markAdClickAttributionsAsExpiredForTesting(PAL::SessionID, CompletionHandler<void()>&&);
 
-    RefPtr<WebCore::StorageQuotaManager> storageQuotaManager(PAL::SessionID, const WebCore::ClientOrigin&);
+    WebCore::StorageQuotaManager& storageQuotaManager(PAL::SessionID, const WebCore::ClientOrigin&);
 
     void addKeptAliveLoad(Ref<NetworkResourceLoader>&&);
@@ -444 +443 @@
     HashSet<WebCore::SecurityOriginData> indexedDatabaseOrigins(const String& path);
     Ref<WebCore::IDBServer::IDBServer> createIDBServer(PAL::SessionID);
-    void setSessionStorageQuotaManagerIDBRootPath(PAL::SessionID, const String& idbRootPath);
 #endif
 
@@ -464 +462 @@
     void ensurePathExists(const String& path);
 
-    class SessionStorageQuotaManager {
-        WTF_MAKE_FAST_ALLOCATED;
-    public:
-        SessionStorageQuotaManager(const String& cacheRootPath, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota)
-            : m_cacheRootPath(cacheRootPath)
-            , m_defaultQuota(defaultQuota)
-            , m_defaultThirdPartyQuota(defaultThirdPartyQuota)
-        {
-        }
-        uint64_t defaultQuota(const WebCore::ClientOrigin& origin) const { return origin.topOrigin == origin.clientOrigin ? m_defaultQuota : m_defaultThirdPartyQuota; }
-
-        Ref<WebCore::StorageQuotaManager> ensureOriginStorageQuotaManager(WebCore::ClientOrigin origin, uint64_t quota, WebCore::StorageQuotaManager::UsageGetter&& usageGetter, WebCore::StorageQuotaManager::QuotaIncreaseRequester&& quotaIncreaseRequester)
-        {
-            auto [iter, isNewEntry] = m_storageQuotaManagers.ensure(origin, [quota, usageGetter = WTFMove(usageGetter), quotaIncreaseRequester = WTFMove(quotaIncreaseRequester)]() mutable {
-                return WebCore::StorageQuotaManager::create(quota, WTFMove(usageGetter), WTFMove(quotaIncreaseRequester));
-            });
-            return makeRef(*iter->value);
-        }
-
-        auto existingStorageQuotaManagers() { return m_storageQuotaManagers.values(); }
-
-        const String& cacheRootPath() const { return m_cacheRootPath; }
-#if ENABLE(INDEXED_DATABASE)
-        void setIDBRootPath(const String& idbRootPath) { m_idbRootPath = idbRootPath; }
-        const String& idbRootPath() const { return m_idbRootPath; }
-#endif
-
-    private:
-        String m_cacheRootPath;
-#if ENABLE(INDEXED_DATABASE)
-        String m_idbRootPath;
-#endif
-        uint64_t m_defaultQuota { WebCore::StorageQuotaManager::defaultQuota() };
-        uint64_t m_defaultThirdPartyQuota { WebCore::StorageQuotaManager::defaultThirdPartyQuota() };
-        HashMap<WebCore::ClientOrigin, RefPtr<WebCore::StorageQuotaManager>> m_storageQuotaManagers;
-    };
-    void addSessionStorageQuotaManager(PAL::SessionID, uint64_t defaultQuota, uint64_t defaultThirdPartyQuota, const String& cacheRootPath, SandboxExtension::Handle&);
-    void removeSessionStorageQuotaManager(PAL::SessionID);
+    void clearStorageQuota(PAL::SessionID);
+    void initializeStorageQuota(const WebsiteDataStoreParameters&);
 
     // Connections to WebProcesses.
@@ -572 +534 @@
 #endif
     
-    Lock m_sessionStorageQuotaManagersLock;
-    HashMap<PAL::SessionID, std::unique_ptr<SessionStorageQuotaManager>> m_sessionStorageQuotaManagers;
+    class StorageQuotaManagers {
+    public:
+        uint64_t defaultQuota(const WebCore::ClientOrigin& origin) const { return origin.topOrigin == origin.clientOrigin ? m_defaultQuota : m_defaultThirdPartyQuota; }
+        void setDefaultQuotas(uint64_t defaultQuota, uint64_t defaultThirdPartyQuota)
+        {
+            m_defaultQuota = defaultQuota;
+            m_defaultThirdPartyQuota = defaultThirdPartyQuota;
+        }
+
+        HashMap<WebCore::ClientOrigin, std::unique_ptr<WebCore::StorageQuotaManager>>& managersPerOrigin() { return m_managersPerOrigin; }
+
+    private:
+        uint64_t m_defaultQuota { WebCore::StorageQuotaManager::defaultQuota() };
+        uint64_t m_defaultThirdPartyQuota { WebCore::StorageQuotaManager::defaultThirdPartyQuota() };
+        HashMap<WebCore::ClientOrigin, std::unique_ptr<WebCore::StorageQuotaManager>> m_managersPerOrigin;
+    };
+    HashMap<PAL::SessionID, StorageQuotaManagers> m_storageQuotaManagers;
 
     OptionSet<NetworkCache::CacheOption> m_cacheOptions;

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

@@ -164 +164 @@
     SetServiceWorkerFetchTimeoutForTesting(Seconds seconds) -> () Synchronous
     ResetServiceWorkerFetchTimeoutForTesting() -> () Synchronous
-
-    ResetQuota(PAL::SessionID sessionID) -> () Async
 }

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

@@ -197 +197 @@
 }
 
-static uint64_t getDirectorySize(const String& directoryPath)
-{
-    ASSERT(!isMainThread());
-
-    uint64_t directorySize = 0;
-    Deque<String> paths;
-    paths.append(directoryPath);
-    while (!paths.isEmpty()) {
-        auto path = paths.takeFirst();
-        if (FileSystem::fileIsDirectory(path, FileSystem::ShouldFollowSymbolicLinks::No)) {
-            auto newPaths = FileSystem::listDirectory(path, "*"_s);
-            for (auto& newPath : newPaths) {
-                // Files in /Blobs directory are hard link.
-                auto fileName = FileSystem::lastComponentOfPathIgnoringTrailingSlash(newPath);
-                if (fileName == "Blobs")
-                    continue;
-                paths.append(newPath);
-            }
-            continue;
-        }
-
-        long long fileSize = 0;
-        FileSystem::getFileSize(path, fileSize);
-        directorySize += fileSize;
-    }
-    return directorySize;
-}
-
-uint64_t Engine::diskUsage(const String& rootPath, const WebCore::ClientOrigin& origin)
-{
-    ASSERT(!isMainThread());
-
-    if (rootPath.isEmpty())
-        return 0;
-
-    String saltPath = FileSystem::pathByAppendingComponent(rootPath, "salt"_s);
-    auto salt = readOrMakeSalt(saltPath);
-    if (!salt)
-        return 0;
-
-    Key key(origin.topOrigin.toString(), origin.clientOrigin.toString(), { }, { }, *salt);
-    String directoryPath = FileSystem::pathByAppendingComponent(rootPath, key.hashAsString());
-
-    String sizeFilePath = Caches::cachesSizeFilename(directoryPath);
-    if (auto recordedSize = readSizeFile(sizeFilePath))
-        return *recordedSize;
-
-    return getDirectorySize(directoryPath);
-}
-
-void Engine::requestSpace(const ClientOrigin& origin, uint64_t spaceRequested, CompletionHandler<void(WebCore::StorageQuotaManager::Decision)>&& callback)
-{
-    ASSERT(isMainThread());
-
-    if (!m_networkProcess)
-        callback(WebCore::StorageQuotaManager::Decision::Deny);
-
-    RefPtr<WebCore::StorageQuotaManager> storageQuotaManager = m_networkProcess->storageQuotaManager(m_sessionID, origin);
-    if (!storageQuotaManager)
-        callback(WebCore::StorageQuotaManager::Decision::Deny);
-
-    storageQuotaManager->requestSpaceOnMainThread(spaceRequested, WTFMove(callback));
+void Engine::initializeQuotaUser(NetworkProcess& networkProcess, PAL::SessionID sessionID, const WebCore::ClientOrigin& clientOrigin, CompletionHandler<void()>&& completionHandler)
+{
+    from(networkProcess, sessionID, [clientOrigin, completionHandler = WTFMove(completionHandler)](auto& engine) mutable {
+        engine.readCachesFromDisk(clientOrigin, [completionHandler = WTFMove(completionHandler)](auto&& cachesOrError) mutable {
+            completionHandler();
+        });
+    });
 }
 
@@ -397 +342 @@
         auto& caches = m_caches.ensure(origin, [&origin, this] {
             auto path = cachesRootPath(origin);
-            return Caches::create(*this, WebCore::ClientOrigin { origin }, WTFMove(path));
+            return Caches::create(*this, WebCore::ClientOrigin { origin }, WTFMove(path), m_networkProcess->storageQuotaManager(m_sessionID, origin));
         }).iterator->value;
 
@@ -529 +474 @@
 }
 
-void Engine::writeSizeFile(const String& path, uint64_t size, CompletionHandler<void()>&& completionHandler)
-{
-    CompletionHandlerCallingScope completionHandlerCaller(WTFMove(completionHandler));
+void Engine::writeSizeFile(const String& path, uint64_t size)
+{
     if (!shouldPersist())
         return;
 
-    m_ioQueue->dispatch([path = path.isolatedCopy(), size, completionHandlerCaller = WTFMove(completionHandlerCaller)]() mutable {
+    m_ioQueue->dispatch([path = path.isolatedCopy(), size]() {
         LockHolder locker(globalSizeFileLock);
         auto fileHandle = FileSystem::openFile(path, FileSystem::FileOpenMode::Write);
@@ -546 +490 @@
         FileSystem::truncateFile(fileHandle, 0);
         FileSystem::writeToFile(fileHandle, String::number(size).utf8().data(), String::number(size).utf8().length());
-
-        RunLoop::main().dispatch([completionHandlerCaller = WTFMove(completionHandlerCaller)]() mutable { });
     });
 }
@@ -572 +514 @@
         return WTF::nullopt;
 
-    Vector<unsigned char> buffer(bytesToRead);
-    size_t totalBytesRead = FileSystem::readFromFile(fileHandle, reinterpret_cast<char*>(buffer.data()), buffer.size());
+    Vector<char> buffer(bytesToRead);
+    size_t totalBytesRead = FileSystem::readFromFile(fileHandle, buffer.data(), buffer.size());
     if (totalBytesRead != bytesToRead)
         return WTF::nullopt;

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

@@ -30 +30 @@
 #include "WebsiteData.h"
 #include <WebCore/ClientOrigin.h>
-#include <WebCore/StorageQuotaManager.h>
 #include <pal/SessionID.h>
 #include <wtf/HashMap.h>
@@ -81 +80 @@
     static void initializeQuotaUser(NetworkProcess&, PAL::SessionID, const WebCore::ClientOrigin&, CompletionHandler<void()>&&);
 
-    static uint64_t diskUsage(const String& rootPath, const WebCore::ClientOrigin&);
-    void requestSpace(const WebCore::ClientOrigin&, uint64_t spaceRequested, CompletionHandler<void(WebCore::StorageQuotaManager::Decision)>&&);
-
     bool shouldPersist() const { return !!m_ioQueue;}
 
@@ -89 +85 @@
     void readFile(const String& filename, CompletionHandler<void(const NetworkCache::Data&, int error)>&&);
     void removeFile(const String& filename);
-    void writeSizeFile(const String&, uint64_t size, CompletionHandler<void()>&&);
+    void writeSizeFile(const String&, uint64_t size);
     static Optional<uint64_t> readSizeFile(const String&);
 

trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCache.cpp

@@ -415 +415 @@
 
         spaceRequired += record.responseBodySize;
-        if (position != notFound) {
-            uint64_t spaceDecreased = sameURLRecords->at(position).size;
-            if (spaceRequired >= spaceDecreased)
-                spaceRequired -= spaceDecreased;
-        }
+        if (position != notFound)
+            spaceRequired -= sameURLRecords->at(position).size;
     }
 
@@ -454 +451 @@
     });
 
-    // This operation would change caches size, so make sure callback finishes after size file is updated.
-    m_caches.updateSizeFile([callback = WTFMove(callback), recordIdentifiers = WTFMove(recordIdentifiers)]() mutable {
-        callback(WTFMove(recordIdentifiers));
-    });
+    callback(WTFMove(recordIdentifiers));
 }
 

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

@@ -57 +57 @@
 }
 
-Ref<Caches> Caches::create(Engine& engine, WebCore::ClientOrigin&& origin, String&& rootPath)
-{
-    return adoptRef(*new Caches { engine, WTFMove(origin), WTFMove(rootPath) });
-}
-
-Caches::Caches(Engine& engine, WebCore::ClientOrigin&& origin, String&& rootPath)
+Ref<Caches> Caches::create(Engine& engine, WebCore::ClientOrigin&& origin, String&& rootPath, WebCore::StorageQuotaManager& quotaManager)
+{
+    auto caches = adoptRef(*new Caches { engine, WTFMove(origin), WTFMove(rootPath), quotaManager });
+    quotaManager.addUser(caches.get());
+    return caches;
+}
+
+Caches::Caches(Engine& engine, WebCore::ClientOrigin&& origin, String&& rootPath, WebCore::StorageQuotaManager& quotaManager)
     : m_engine(&engine)
     , m_origin(WTFMove(origin))
     , m_rootPath(WTFMove(rootPath))
+    , m_quotaManager(makeWeakPtr(quotaManager))
 {
 }
@@ -72 +75 @@
 {
     ASSERT(m_pendingWritingCachesToDiskCallbacks.isEmpty());
+
+    if (m_quotaManager)
+        m_quotaManager->removeUser(*this);
+}
+
+void Caches::whenInitialized(CompletionHandler<void()>&& callback)
+{
+    initialize([callback = WTFMove(callback)](auto&& error) mutable {
+        if (error)
+            RELEASE_LOG_ERROR(CacheStorage, "Caches::initialize failed, reported space used will be zero");
+        callback();
+    });
 }
 
@@ -194 +209 @@
 }
 
-void Caches::updateSizeFile(CompletionHandler<void()>&& completionHandler)
-{
-    if (!m_engine) {
-        completionHandler();
-        return;
-    }
-
-    m_engine->writeSizeFile(cachesSizeFilename(m_rootPath), m_size, WTFMove(completionHandler));
+void Caches::updateSizeFile()
+{
+    if (m_engine)
+        m_engine->writeSizeFile(cachesSizeFilename(m_rootPath), m_size);
 }
 
@@ -222 +233 @@
             }
             m_size = size;
-            updateSizeFile([this, protectedThis = WTFMove(protectedThis)]() mutable {
-                m_isInitialized = true;
-                auto pendingCallbacks = WTFMove(m_pendingInitializationCallbacks);
-                for (auto& callback : pendingCallbacks)
-                    callback(WTF::nullopt);
-            });
+            updateSizeFile();
+
+            m_isInitialized = true;
+            auto pendingCallbacks = WTFMove(m_pendingInitializationCallbacks);
+            for (auto& callback : pendingCallbacks)
+                callback(WTF::nullopt);
+
             return;
         }
@@ -262 +274 @@
             ASSERT(RunLoop::isMain());
             protectedThis->clearMemoryRepresentation();
+            protectedThis->resetSpaceUsed();
             completionHandler();
         });
@@ -267 +280 @@
     }
     clearMemoryRepresentation();
+    resetSpaceUsed();
     clearPendingWritingCachesToDiskCallbacks();
     completionHandler();
@@ -512 +526 @@
 void Caches::requestSpace(uint64_t spaceRequired, WebCore::DOMCacheEngine::CompletionCallback&& callback)
 {
-    if (!m_engine) {
+    if (!m_quotaManager) {
         callback(Error::QuotaExceeded);
         return;
     }
 
-    m_engine->requestSpace(m_origin, spaceRequired, [callback = WTFMove(callback)](auto decision) mutable {
+    m_quotaManager->requestSpace(spaceRequired, [callback = WTFMove(callback)](auto decision) mutable {
         switch (decision) {
         case WebCore::StorageQuotaManager::Decision::Deny:
@@ -535 +549 @@
     m_size += recordInformation.size;
     m_size -= previousRecordSize;
+    updateSizeFile();
 
     if (!shouldPersist()) {
@@ -542 +557 @@
     }
 
-    m_storage->store(Cache::encode(recordInformation, record), { }, [this, protectedThis = makeRef(*this), protectedStorage = makeRef(*m_storage), callback = WTFMove(callback)](int error) mutable {
+    m_storage->store(Cache::encode(recordInformation, record), { }, [protectedStorage = makeRef(*m_storage), callback = WTFMove(callback)](int error) mutable {
         if (error) {
             RELEASE_LOG_ERROR(CacheStorage, "Caches::writeRecord failed with error %d", error);
@@ -548 +563 @@
             return;
         }
-        updateSizeFile([callback = WTFMove(callback)]() mutable {
-            callback(WTF::nullopt);
-        });
+        callback(WTF::nullopt);
     });
 }
@@ -593 +606 @@
     ASSERT(m_size >= record.size);
     m_size -= record.size;
-    updateSizeFile([] { });
+    updateSizeFile();
 
     removeCacheEntry(record.key);
@@ -607 +620 @@
     }
     m_storage->remove(key);
+}
+
+void Caches::resetSpaceUsed()
+{
+    m_size = 0;
+    updateSizeFile();
+
+    if (m_quotaManager) {
+        m_quotaManager->removeUser(*this);
+        m_quotaManager->addUser(*this);
+    }
 }
 

trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.h

@@ -29 +29 @@
 #include "NetworkCacheStorage.h"
 #include <WebCore/ClientOrigin.h>
+#include <WebCore/StorageQuotaUser.h>
 #include <wtf/CompletionHandler.h>
 #include <wtf/Deque.h>
@@ -42 +43 @@
 class Engine;
 
-class Caches final : public RefCounted<Caches> {
+class Caches final : public RefCounted<Caches>, private WebCore::StorageQuotaUser {
 public:
-    static String cachesSizeFilename(const String& cachesRootsPath);
-    static Ref<Caches> create(Engine&, WebCore::ClientOrigin&&, String&& rootPath);
+    static String cachesSizeFilename(const String&);
+    static Ref<Caches> create(Engine&, WebCore::ClientOrigin&&, String&& rootPath, WebCore::StorageQuotaManager&);
     ~Caches();
 
@@ -79 +80 @@
     void clear(WTF::CompletionHandler<void()>&&);
     void clearMemoryRepresentation();
+    void resetSpaceUsed();
 
     uint64_t storageSize() const;
-    void updateSizeFile(CompletionHandler<void()>&&);
 
 private:
-    Caches(Engine&, WebCore::ClientOrigin&&, String&& rootPath);
+    Caches(Engine&, WebCore::ClientOrigin&&, String&& rootPath, WebCore::StorageQuotaManager&);
+
+    // StorageQuotaUser API.
+    uint64_t spaceUsed() const final { return m_size; }
 
     void initializeSize();
     void readCachesFromDisk(WTF::Function<void(Expected<Vector<Cache>, WebCore::DOMCacheEngine::Error>&&)>&&);
     void writeCachesToDisk(WebCore::DOMCacheEngine::CompletionCallback&&);
+
+    void whenInitialized(CompletionHandler<void()>&&) final;
 
     void storeOrigin(WebCore::DOMCacheEngine::CompletionCallback&&);
@@ -100 +106 @@
 
     bool hasActiveCache() const;
+
+    void updateSizeFile();
 
     bool m_isInitialized { false };
@@ -115 +123 @@
     bool m_isWritingCachesToDisk { false };
     Deque<CompletionHandler<void(Optional<WebCore::DOMCacheEngine::Error>)>> m_pendingWritingCachesToDiskCallbacks;
+    WeakPtr<WebCore::StorageQuotaManager> m_quotaManager;
 };
 

trunk/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp

@@ -55 +55 @@
 
     encoder << localStorageDirectory << localStorageDirectoryExtensionHandle;
-
-    encoder << cacheStorageDirectory << cacheStorageDirectoryExtensionHandle;
 
     encoder << perOriginStorageQuota;
@@ -144 +142 @@
     parameters.localStorageDirectoryExtensionHandle = WTFMove(*localStorageDirectoryExtensionHandle);
 
-    Optional<String> cacheStorageDirectory;
-    decoder >> cacheStorageDirectory;
-    if (!cacheStorageDirectory)
-        return WTF::nullopt;
-    parameters.cacheStorageDirectory = WTFMove(*cacheStorageDirectory);
-
-    Optional<SandboxExtension::Handle> cacheStorageDirectoryExtensionHandle;
-    decoder >> cacheStorageDirectoryExtensionHandle;
-    if (!cacheStorageDirectoryExtensionHandle)
-        return WTF::nullopt;
-    parameters.cacheStorageDirectoryExtensionHandle = WTFMove(*cacheStorageDirectoryExtensionHandle);
-
     Optional<uint64_t> perOriginStorageQuota;
     decoder >> perOriginStorageQuota;

trunk/Source/WebKit/Shared/WebsiteDataStoreParameters.h

@@ -72 +72 @@
     SandboxExtension::Handle localStorageDirectoryExtensionHandle;
 
-    String cacheStorageDirectory;
-    SandboxExtension::Handle cacheStorageDirectoryExtensionHandle;
-
     uint64_t perOriginStorageQuota { WebCore::StorageQuotaManager::defaultQuota() };
     uint64_t perThirdPartyOriginStorageQuota { WebCore::StorageQuotaManager::defaultThirdPartyQuota() };

trunk/Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.cpp

@@ -687 +687 @@
     WebKit::toImpl(dataStoreRef)->setCacheModelSynchronouslyForTesting(WebKit::toCacheModel(cacheModel));
 }
-
-void WKWebsiteDataStoreResetQuota(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreResetQuotaCallback callback)
-{
-    WebKit::toImpl(dataStoreRef)->resetQuota([context, callback] {
-        if (callback)
-            callback(context);
-    });
-}

trunk/Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.h

@@ -156 +156 @@
 WK_EXPORT void WKWebsiteDataStoreSetCacheModelSynchronouslyForTesting(WKWebsiteDataStoreRef dataStoreRef, WKCacheModel cacheModel);
 
-typedef void (*WKWebsiteDataStoreResetQuotaCallback)(void* functionContext);
-WK_EXPORT void WKWebsiteDataStoreResetQuota(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreResetQuotaCallback callback);
-
 #ifdef __cplusplus
 }

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

@@ -1368 +1368 @@
 }
 
-void NetworkProcessProxy::resetQuota(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
-{
-    sendWithAsyncReply(Messages::NetworkProcess::ResetQuota(sessionID), WTFMove(completionHandler));
-}
-
 } // namespace WebKit
 

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

@@ -57 +57 @@
 class SecurityOrigin;
 struct SecurityOriginData;
-struct ClientOrigin;
 }
 
@@ -198 +197 @@
     void unregisterSchemeForLegacyCustomProtocol(const String&);
 
-    void resetQuota(PAL::SessionID, CompletionHandler<void()>&&);
-
 private:
     // AuxiliaryProcessProxy

trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

@@ -552 +552 @@
     SandboxExtension::createHandleForReadWriteDirectory(localStorageDirectory, parameters.defaultDataStoreParameters.localStorageDirectoryExtensionHandle);
 
-    auto cacheStorageDirectory = m_websiteDataStore ? m_websiteDataStore->cacheStorageDirectory() : nullString();
-    if (!cacheStorageDirectory.isEmpty()) {
-        SandboxExtension::createHandleForReadWriteDirectory(cacheStorageDirectory, parameters.defaultDataStoreParameters.cacheStorageDirectoryExtensionHandle);
-        parameters.defaultDataStoreParameters.cacheStorageDirectory = WTFMove(cacheStorageDirectory);
-    }
-
     if (m_websiteDataStore)
         parameters.defaultDataStoreParameters.networkSessionParameters.resourceLoadStatisticsDirectory = m_websiteDataStore->resolvedResourceLoadStatisticsDirectory();

trunk/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm

@@ -192 +192 @@
         SandboxExtension::createHandleForReadWriteDirectory(parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle);
 
-    parameters.cacheStorageDirectory = cacheStorageDirectory();
-    if (!parameters.cacheStorageDirectory.isEmpty())
-        SandboxExtension::createHandleForReadWriteDirectory(parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);
-
     parameters.perOriginStorageQuota = perOriginStorageQuota();
     parameters.perThirdPartyOriginStorageQuota = perThirdPartyOriginStorageQuota();

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

@@ -2084 +2084 @@
     }
 
-    auto cacheStorageDirectory = this->cacheStorageDirectory();
-    if (!cacheStorageDirectory.isEmpty()) {
-        SandboxExtension::createHandleForReadWriteDirectory(cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);
-        parameters.cacheStorageDirectory = cacheStorageDirectory;
-    }
-
 #if ENABLE(INDEXED_DATABASE)
     parameters.indexedDatabaseDirectory = resolvedIndexedDatabaseDirectory();
@@ -2176 +2170 @@
 }
 
-void WebsiteDataStore::resetQuota(CompletionHandler<void()>&& completionHandler)
-{
-    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
-    for (auto& processPool : processPools()) {
-        if (auto* process = processPool->networkProcess())
-            process->resetQuota(m_sessionID, [callbackAggregator = callbackAggregator.copyRef()] { });
-    }
-}
-
 #if !PLATFORM(COCOA)
 WTF::String WebsiteDataStore::defaultMediaCacheDirectory()

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

@@ -292 +292 @@
     static WTF::String defaultDeviceIdHashSaltsStorageDirectory();
     static WTF::String defaultJavaScriptConfigurationDirectory();
-
-    void resetQuota(CompletionHandler<void()>&&);
-
+    
 private:
     void fetchDataAndApply(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, RefPtr<WorkQueue>&&, Function<void(Vector<WebsiteDataRecord>)>&& apply);

trunk/Tools/ChangeLog

@@ +1 @@
+2019-11-23  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r252805.
+        https://bugs.webkit.org/show_bug.cgi?id=204553
+
+        Caused test failures and ASan crashes (Requested by ap on
+        #webkit).
+
+        Reverted changeset:
+
+        "Cross-thread version StorageQuotaManager"
+        https://bugs.webkit.org/show_bug.cgi?id=203971
+        https://trac.webkit.org/changeset/252805
+
 2019-11-23  Per Arne Vollan  <pvollan@apple.com>
 

trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj

@@ -739 +739 @@
                 93AF4ECE1506F064007FD57E /* NewFirstVisuallyNonEmptyLayoutForImages_Bundle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93AF4ECD1506F064007FD57E /* NewFirstVisuallyNonEmptyLayoutForImages_Bundle.cpp */; };
                 93AF4ED11506F130007FD57E /* lots-of-images.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 93AF4ECF1506F123007FD57E /* lots-of-images.html */; };
+                93B62054234EA62C00D49B97 /* StorageQuotaManager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93B62053234EA32B00D49B97 /* StorageQuotaManager.cpp */; };
                 93CFA8671CEB9E38000565A8 /* autofocused-text-input.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 93CFA8661CEB9DE1000565A8 /* autofocused-text-input.html */; };
                 93D119FC22C680F7009BE3C7 /* localstorage-open-window-private.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 93D119FB22C57112009BE3C7 /* localstorage-open-window-private.html */; };
@@ -1143 +1144 @@
                         dstSubfolderSpec = 7;
                         files = (
+                                CD8394DF232AF7C000149495 /* media-loading.html in Copy Resources */,
                                 55A817FF2181021A0004A39A /* 100x100-red.tga in Copy Resources */,
                                 1A9E52C913E65EF4006917F5 /* 18-characters.html in Copy Resources */,
@@ -1375 +1377 @@
                                 AD57AC221DA7466E00FF1BDE /* many-iframes.html in Copy Resources */,
                                 7772ECE122FE06C60009A799 /* many-same-origin-iframes.html in Copy Resources */,
-                                CD8394DF232AF7C000149495 /* media-loading.html in Copy Resources */,
                                 CDA3159A1ED548F1009F60D3 /* MediaPlaybackSleepAssertion.html in Copy Resources */,
                                 CDC9442F1EF205D60059C3C4 /* mediastreamtrack-detached.html in Copy Resources */,
@@ -2149 +2150 @@
                 93AF4ECD1506F064007FD57E /* NewFirstVisuallyNonEmptyLayoutForImages_Bundle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NewFirstVisuallyNonEmptyLayoutForImages_Bundle.cpp; sourceTree = "<group>"; };
                 93AF4ECF1506F123007FD57E /* lots-of-images.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "lots-of-images.html"; sourceTree = "<group>"; };
+                93B62053234EA32B00D49B97 /* StorageQuotaManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageQuotaManager.cpp; sourceTree = "<group>"; };
                 93CFA8661CEB9DE1000565A8 /* autofocused-text-input.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "autofocused-text-input.html"; sourceTree = "<group>"; };
                 93CFA8681CEBCFED000565A8 /* CandidateTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CandidateTests.mm; sourceTree = "<group>"; };
@@ -3126 +3128 @@
                                 A17991891E1CA24100A505ED /* SharedBufferTest.cpp */,
                                 A179918A1E1CA24100A505ED /* SharedBufferTest.h */,
+                                93B62053234EA32B00D49B97 /* StorageQuotaManager.cpp */,
                                 ECA680CD1E68CC0900731D20 /* StringUtilities.mm */,
                                 CE4D5DE51F6743BA0072CFC6 /* StringWithDirection.cpp */,
@@ -3853 +3856 @@
                                 AD57AC1D1DA7463800FF1BDE /* many-iframes.html */,
                                 7772ECE022FE05E10009A799 /* many-same-origin-iframes.html */,
-                                CD8394DE232AF15E00149495 /* media-loading.html */,
                                 CDC9442B1EF1FBD20059C3C4 /* mediastreamtrack-detached.html */,
                                 51CD1C711B38D48400142CA5 /* modal-alerts-in-new-about-blank-window.html */,
@@ -3885 +3887 @@
                                 1C2B81841C8924A200A5529F /* webfont.html */,
                                 468F2F932368DAA700F4B864 /* window-open-then-document-open.html */,
+                                CD8394DE232AF15E00149495 /* media-loading.html */,
                         );
                         name = Resources;
@@ -4866 +4869 @@
                                 CDC0932E21C993440030C4B0 /* StopSuspendResumeAllMedia.mm in Sources */,
                                 414AD6862285D1C000777F2D /* StorageQuota.mm in Sources */,
+                                93B62054234EA62C00D49B97 /* StorageQuotaManager.cpp in Sources */,
                                 515BE1711D428E4B00DD7C68 /* StoreBlobThenDelete.mm in Sources */,
                                 7CCE7ED01A411A7E00447C4C /* StringByEvaluatingJavaScriptFromString.mm in Sources */,

trunk/Tools/WebKitTestRunner/TestController.cpp

@@ -982 +982 @@
     clearDOMCaches();
 
-    resetQuota();
-
     WKContextSetAllowsAnySSLCertificateForServiceWorkerTesting(platformContext(), true);
 
@@ -3145 +3143 @@
 }
 
-void TestController::resetQuota()
-{
-    StorageVoidCallbackContext context(*this);
-    WKWebsiteDataStoreResetQuota(TestController::websiteDataStore(), &context, StorageVoidCallback);
-    runUntil(context.done, noTimeout);
-}
-
 struct FetchCacheOriginsCallbackContext {
     FetchCacheOriginsCallbackContext(TestController& controller, WKStringRef origin)

trunk/Tools/WebKitTestRunner/TestController.h

@@ -270 +270 @@
     void terminateServiceWorkerProcess();
 
-    void resetQuota();
-
     void removeAllSessionCredentials();