Attachment 356991 Details for Bug 192556 – Patch

[patch] Patch

bug-192556-20181210133803.patch (text/plain), 79.72 KB, created by Sihui Liu on 2018-12-10 13:38:03 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Sihui Liu

Created: 2018-12-10 13:38:03 PST

Size: 79.72 KB

patch

obsolete

>Subversion Revision: 239035
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index ee7eb659e636afbc2477fc21d5efa63a24d6a1dd..b259d8a2099677a48f6ff8aa16b43eebd636cea7 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,83 @@
>+2018-12-10  Sihui Liu  <sihui_liu@apple.com>
>+
>+        IndexedDB: quota should be able to increase
>+        https://bugs.webkit.org/show_bug.cgi?id=192556
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Instead of setting a fixed high storage limit, now we have a small initail IDB quota and 
>+        make it increase on demand.
>+
>+        Test modified to include new behavior: storage/indexeddb/storage-limit.html
>+
>+        * Modules/indexeddb/IDBDatabaseIdentifier.cpp:
>+        (WebCore::IDBDatabaseIdentifier::originString const):
>+        * Modules/indexeddb/IDBDatabaseIdentifier.h:
>+        * Modules/indexeddb/IDBOpenDBRequest.cpp:
>+        (WebCore::IDBOpenDBRequest::requestCompleted):
>+        * Modules/indexeddb/IDBRequest.cpp:
>+        (WebCore::IDBRequest::completeRequestAndDispatchEvent):
>+        (WebCore::IDBRequest::databaseExceededQuota):
>+        * Modules/indexeddb/IDBRequest.h:
>+        * Modules/indexeddb/client/IDBConnectionProxy.cpp:
>+        (WebCore::IDBClient::IDBConnectionProxy::updateQuotaForOrigin):
>+        * Modules/indexeddb/client/IDBConnectionProxy.h:
>+        * Modules/indexeddb/client/IDBConnectionToServer.cpp:
>+        (WebCore::IDBClient::IDBConnectionToServer::updateQuotaForOrigin):
>+        * Modules/indexeddb/client/IDBConnectionToServer.h:
>+        * Modules/indexeddb/client/IDBConnectionToServerDelegate.h:
>+        * Modules/indexeddb/server/IDBServer.cpp:
>+        (WebCore::IDBServer::IDBServer::quotaDatabasePath const):
>+        (WebCore::IDBServer::IDBServer::openQuotaDatabase):
>+        (WebCore::IDBServer::IDBServer::quotaForOrigin):
>+        (WebCore::IDBServer::IDBServer::setQuotaInDatabase):
>+        (WebCore::IDBServer::IDBServer::deleteOriginFromDatabase):
>+        (WebCore::IDBServer::IDBServer::mayDeleteQuotaDatabase):
>+        (WebCore::IDBServer::IDBServer::mayDeleteOriginFromDatabase):
>+        (WebCore::IDBServer::IDBServer::setQuotaForOrigin):
>+        (WebCore::IDBServer::IDBServer::isQuotaFullForOrigin):
>+        (WebCore::IDBServer::IDBServer::createBackingStore):
>+        (WebCore::IDBServer::IDBServer::closeAndTakeUniqueIDBDatabase):
>+        (WebCore::IDBServer::IDBServer::performCloseAndDeleteDatabasesForOrigins):
>+        * Modules/indexeddb/server/IDBServer.h:
>+        * Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::originDiskUsage):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::databaseSize const):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::maximumSize const):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::beginTransaction):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::createObjectStore):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::renameObjectStore):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::createIndex):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedPutIndexRecord):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::renameIndex):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::addRecord):
>+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedSetKeyGeneratorValue):
>+        * Modules/indexeddb/server/SQLiteIDBBackingStore.h:
>+        * Modules/indexeddb/server/UniqueIDBDatabase.cpp:
>+        (WebCore::IDBServer::UniqueIDBDatabase::deleteBackingStore):
>+        (WebCore::IDBServer::UniqueIDBDatabase::openBackingStore):
>+        (WebCore::IDBServer::UniqueIDBDatabase::setQuota):
>+        (WebCore::IDBServer::UniqueIDBDatabase::performSetQuota):
>+        * Modules/indexeddb/server/UniqueIDBDatabase.h:
>+        * Modules/indexeddb/shared/IDBError.cpp:
>+        (WebCore::IDBError::IDBError):
>+        (WebCore::IDBError::isolatedCopy const):
>+        (WebCore::IDBError::operator=):
>+        * Modules/indexeddb/shared/IDBError.h:
>+        (WebCore::IDBError::IDBError):
>+        (WebCore::IDBError::quotaDetails const):
>+        (WebCore::IDBError::encode const):
>+        (WebCore::IDBError::decode):
>+        * Modules/indexeddb/shared/InProcessIDBServer.cpp:
>+        (WebCore::InProcessIDBServer::updateQuotaForOrigin):
>+        * Modules/indexeddb/shared/InProcessIDBServer.h:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * loader/EmptyClients.h:
>+        * page/ChromeClient.h:
>+        * page/SecurityOriginData.cpp:
>+        (WebCore::SecurityOriginData::fromOriginIdentifier):
>+        * page/SecurityOriginData.h:
>+
> 2018-12-10  Truitt Savell  <tsavell@apple.com>
> 
>         Unreviewed, rolling out r238965.
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 0a659c632294fd9b6f0fa5323804349cd31f735e..50207076d76d0a8335b1ab4e6829a573dfb45806 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,23 @@
>+2018-12-10  Sihui Liu  <sihui_liu@apple.com>
>+
>+        IndexedDB: quota should be able to increase
>+        https://bugs.webkit.org/show_bug.cgi?id=192556
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp:
>+        (WebKit::WebIDBConnectionToClient::updateQuotaForOrigin):
>+        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.h:
>+        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in:
>+        * UIProcess/WebPageProxy.cpp:
>+        (WebKit::WebPageProxy::exceededDatabaseQuota):
>+        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
>+        (WebKit::WebIDBConnectionToServer::updateQuotaForOrigin):
>+        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h:
>+        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
>+        (WebKit::WebChromeClient::exceededDatabaseQuota):
>+        * WebProcess/WebCoreSupport/WebChromeClient.h:
>+
> 2018-12-10  Alexey Proskuryakov  <ap@apple.com>
> 
>         Move ENABLE_SEC_ITEM_SHIM out of WebKit's config.h
>diff --git a/Source/WebKitLegacy/mac/ChangeLog b/Source/WebKitLegacy/mac/ChangeLog
>index fb802562becc96b6ca07601fc8f739c04e145678..16dbd5c4d6fc6d7df0724ff36cb638ab37e666e4 100644
>--- a/Source/WebKitLegacy/mac/ChangeLog
>+++ b/Source/WebKitLegacy/mac/ChangeLog
>@@ -1,3 +1,14 @@
>+2018-12-10  Sihui Liu  <sihui_liu@apple.com>
>+
>+        IndexedDB: quota should be able to increase
>+        https://bugs.webkit.org/show_bug.cgi?id=192556
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * WebCoreSupport/WebChromeClient.h:
>+        * WebCoreSupport/WebChromeClient.mm:
>+        (WebChromeClient::exceededDatabaseQuota):
>+
> 2018-12-10  Darin Adler  <darin@apple.com>
> 
>         [macOS] MSHCreateMIGServerSource invocation does not handle send/receive rights correctly
>diff --git a/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.cpp b/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.cpp
>index c7fdfd0dd6545f8c6fe5342fb3646fe9a84694b9..60358a3079eef928e85798ef694a8de286bf82b1 100644
>--- a/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.cpp
>+++ b/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.cpp
>@@ -74,6 +74,17 @@ String IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(const SecurityOrig
>     return FileSystem::pathByAppendingComponent(mainFrameDirectory, openingOrigin.databaseIdentifier());
> }
> 
>+String IDBDatabaseIdentifier::originString() const
>+{
>+    StringBuilder stringBuilder;
>+
>+    stringBuilder.append(m_mainFrameOrigin.databaseIdentifier());
>+    stringBuilder.append('/');
>+    stringBuilder.append(m_openingOrigin.databaseIdentifier());
>+
>+    return stringBuilder.toString();
>+}
>+
> #if !LOG_DISABLED
> String IDBDatabaseIdentifier::debugString() const
> {
>diff --git a/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h b/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h
>index 7de4cdad3e1dcdb01c3aaf44f025671762d25bb7..48c0c273f8b3cdffc6704561e4a762e7b5b82ddb 100644
>--- a/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h
>+++ b/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h
>@@ -93,6 +93,8 @@ public:
>     template<class Encoder> void encode(Encoder&) const;
>     template<class Decoder> static std::optional<IDBDatabaseIdentifier> decode(Decoder&);
> 
>+    String originString() const;
>+
> #if !LOG_DISABLED
>     String debugString() const;
> #endif
>diff --git a/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp b/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp
>index 91ce9c4cb9454cebaa104f8943cb42bf51c635d2..d8e96ac2f3bf58af6957dc172ffa9ccfe2673879 100644
>--- a/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp
>+++ b/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp
>@@ -205,6 +205,8 @@ void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
>     switch (data.type()) {
>     case IDBResultType::Error:
>         onError(data);
>+        if (data.error().code() == QuotaExceededError)
>+            databaseExceededQuota(data.error().quotaDetails());
>         break;
>     case IDBResultType::OpenDatabaseSuccess:
>         onSuccess(data);
>diff --git a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp b/Source/WebCore/Modules/indexeddb/IDBRequest.cpp
>index 6f5ce0e972653f6573ad5db76a4fccd49f22da9b..28e7d1cf2df8063d412b02cf1c353de03c41a936 100644
>--- a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp
>+++ b/Source/WebCore/Modules/indexeddb/IDBRequest.cpp
>@@ -28,6 +28,8 @@
> 
> #if ENABLE(INDEXED_DATABASE)
> 
>+#include "Chrome.h"
>+#include "ChromeClient.h"
> #include "DOMException.h"
> #include "Event.h"
> #include "EventDispatcher.h"
>@@ -501,9 +503,11 @@ void IDBRequest::completeRequestAndDispatchEvent(const IDBResultData& resultData
>     m_readyState = ReadyState::Done;
> 
>     m_idbError = resultData.error();
>-    if (!m_idbError.isNull())
>+    if (!m_idbError.isNull()) {
>         onError();
>-    else
>+        if (m_idbError.code() == QuotaExceededError)
>+            databaseExceededQuota(m_idbError.quotaDetails());
>+    } else
>         onSuccess();
> }
> 
>@@ -532,6 +536,19 @@ void IDBRequest::setResult(Ref<IDBDatabase>&& database)
>     m_result = Result { RefPtr<IDBDatabase> { WTFMove(database) } };
> }
> 
>+void IDBRequest::databaseExceededQuota(const IDBQuotaDetails& details)
>+{
>+    uint64_t newQuota = 0;
>+    if (is<Document>(*scriptExecutionContext())) {
>+        Document& document = downcast<Document>(*scriptExecutionContext());
>+        if (Page* page = document.page())
>+            newQuota = page->chrome().client().exceededDatabaseQuota(*document.frame(), details);
>+    }
>+    
>+    if (newQuota)
>+        m_connectionProxy->updateQuotaForOrigin(details.origin(), newQuota);
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebCore/Modules/indexeddb/IDBRequest.h b/Source/WebCore/Modules/indexeddb/IDBRequest.h
>index e625cd3c7fbdc8913d6d49aa340ed9bb7239b5e8..3b1f2505809ec0449d1ebbd9c210a82f31eb8dbe 100644
>--- a/Source/WebCore/Modules/indexeddb/IDBRequest.h
>+++ b/Source/WebCore/Modules/indexeddb/IDBRequest.h
>@@ -117,6 +117,8 @@ public:
> 
>     bool hasPendingActivity() const final;
> 
>+    void databaseExceededQuota(const IDBQuotaDetails&);
>+
> protected:
>     IDBRequest(ScriptExecutionContext&, IDBClient::IDBConnectionProxy&);
> 
>diff --git a/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp b/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp
>index 15ac07e46445f43414d45f8b128666cb27c4c00c..c3c5feda3eafe0c333d76111a88e804b901a0ad9 100644
>--- a/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp
>+++ b/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp
>@@ -493,6 +493,11 @@ void IDBConnectionProxy::getAllDatabaseNames(const SecurityOrigin& mainFrameOrig
>     m_connectionToServer.getAllDatabaseNames(mainFrameOrigin, openingOrigin, WTFMove(callback));
> }
> 
>+void IDBConnectionProxy::updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota)
>+{
>+    callConnectionOnMainThread(&IDBConnectionToServer::updateQuotaForOrigin, originIdentifierString, quota);
>+}
>+
> void IDBConnectionProxy::registerDatabaseConnection(IDBDatabase& database)
> {
>     Locker<Lock> locker(m_databaseConnectionMapLock);
>diff --git a/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h b/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h
>index 2d039bf0fa8e951ed3ad3d2a4cb5ce5926f77f25..0be11448a6bbe0a5109294f42736664a42111563 100644
>--- a/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h
>+++ b/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h
>@@ -118,6 +118,8 @@ public:
> 
>     void getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, WTF::Function<void (const Vector<String>&)>&&);
> 
>+    void updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota);
>+
>     void registerDatabaseConnection(IDBDatabase&);
>     void unregisterDatabaseConnection(IDBDatabase&);
> 
>diff --git a/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp b/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp
>index fb50f6944ceaf07bac105054a925e1b3a939a25d..31947d047901855a3da78695c0b5b6deed6d2a5a 100644
>--- a/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp
>+++ b/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp
>@@ -525,6 +525,15 @@ void IDBConnectionToServer::didGetAllDatabaseNames(uint64_t callbackID, const Ve
>     callback(databaseNames);
> }
> 
>+void IDBConnectionToServer::updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota)
>+{
>+    LOG(IndexedDB, "IDBConnectionToServer::updateQuotaForOrigin %s", originIdentifierString.utf8().data());
>+    ASSERT(isMainThread());
>+    
>+    if (m_serverConnectionIsValid)
>+        m_delegate->updateQuotaForOrigin(originIdentifierString, quota);
>+}
>+
> } // namespace IDBClient
> } // namespace WebCore
> 
>diff --git a/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h b/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h
>index 851c342c4053c2f12daba2dc1341a7eef051707b..9ca4c92212e8e84d54368ea4d32493877b7a98d9 100644
>--- a/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h
>+++ b/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h
>@@ -140,6 +140,8 @@ public:
>     void getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, WTF::Function<void (const Vector<String>&)>&&);
>     WEBCORE_EXPORT void didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames);
> 
>+    void updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota);
>+
> private:
>     IDBConnectionToServer(IDBConnectionToServerDelegate&);
> 
>diff --git a/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServerDelegate.h b/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServerDelegate.h
>index f217926ae06913ada8c3083e61fb2acefd8341e1..ecb7db96464adc688d384a2a04e6dc45f6badda2 100644
>--- a/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServerDelegate.h
>+++ b/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServerDelegate.h
>@@ -88,6 +88,8 @@ public:
> 
>     virtual void getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID) = 0;
> 
>+    virtual void updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota) = 0;
>+
>     virtual void ref() = 0;
>     virtual void deref() = 0;
> };
>diff --git a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp b/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp
>index cb17ba1d579b6d2599ff4c5bcefdfe2faef4bea0..c730f655e7212efa6f0ae24027403e80e671406f 100644
>--- a/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp
>+++ b/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp
>@@ -34,6 +34,7 @@
> #include "MemoryIDBBackingStore.h"
> #include "SQLiteFileSystem.h"
> #include "SQLiteIDBBackingStore.h"
>+#include "SQLiteStatement.h"
> #include "SecurityOrigin.h"
> #include <wtf/CrossThreadCopier.h>
> #include <wtf/Locker.h>
>@@ -108,6 +109,153 @@ void IDBServer::unregisterDatabaseConnection(UniqueIDBDatabaseConnection& connec
>     m_databaseConnections.remove(connection.identifier());
> }
> 
>+String IDBServer::quotaDatabasePath() const
>+{
>+    if (!SQLiteFileSystem::ensureDatabaseDirectoryExists(m_databaseDirectoryPath)) {
>+        LOG_ERROR("Unable to create IDB database path %s", m_databaseDirectoryPath.utf8().data());
>+        return String();
>+    }
>+    return FileSystem::pathByAppendingComponent(m_databaseDirectoryPath, "Quota.db");
>+}
>+
>+void IDBServer::openQuotaDatabase()
>+{
>+    ASSERT(!isMainThread());
>+
>+    if (m_quotaDatabase.isOpen())
>+        return;
>+
>+    auto databasePath = quotaDatabasePath();
>+    if (!databasePath)
>+        return;
>+
>+    if (!m_quotaDatabase.open(databasePath)) {
>+        LOG_ERROR("Failed to open quotaDatabase at path %s.", databasePath.ascii().data());
>+        return;
>+    }
>+    m_quotaDatabase.disableThreadingChecks();
>+    
>+    if (m_quotaDatabase.tableExists("Quota"))
>+        return;
>+
>+    if (!m_quotaDatabase.executeCommand("CREATE TABLE Quota (origin TEXT UNIQUE ON CONFLICT REPLACE, quota INTEGER NOT NULL ON CONFLICT FAIL);"))
>+        LOG_ERROR("Failed to create Quota table.");
>+}
>+
>+uint64_t IDBServer::quotaForOrigin(const String& originIdentifierString)
>+{
>+    ASSERT(!isMainThread());
>+
>+    uint64_t quota = m_perOriginQuota;
>+
>+    openQuotaDatabase();
>+    if (!m_quotaDatabase.isOpen())
>+        return quota;
>+
>+    SQLiteStatement statement(m_quotaDatabase, "SELECT quota FROM Quota where origin=?;");
>+    if (statement.prepare() != SQLITE_OK) {
>+        LOG_ERROR("Failed to prepare getting quota for origin %s in quota database.", originIdentifierString.utf8().data());
>+        return quota;
>+    }
>+    statement.bindText(1, originIdentifierString);
>+
>+    auto result = statement.step();
>+    if (result == SQLITE_ROW)
>+        quota = statement.getColumnInt64(0);
>+    else if (result == SQLITE_DONE)
>+        setQuotaInDatabase(originIdentifierString, quota);
>+    else
>+        LOG_ERROR("Failed to get quota for origin %s in quota database.", originIdentifierString.utf8().data());
>+
>+    return quota;
>+}
>+
>+void IDBServer::setQuotaInDatabase(const String& originIdentifierString, uint64_t quota)
>+{
>+    ASSERT(!isMainThread());
>+
>+    openQuotaDatabase();
>+    if (!m_quotaDatabase.isOpen())
>+        return;
>+    
>+    SQLiteStatement statement(m_quotaDatabase, "INSERT OR REPLACE INTO Quota VALUES (?, ?)");
>+    if (statement.prepare() != SQLITE_OK) {
>+        LOG_ERROR("Failed to prepare insertion for origin %s in quota database", originIdentifierString.utf8().data());
>+        return;
>+    }
>+    
>+    statement.bindText(1, originIdentifierString);
>+    statement.bindInt64(2, quota);
>+    
>+    if (statement.step() != SQLITE_DONE)
>+        LOG_ERROR("Failed to execute insertion for origin %s in quota database", originIdentifierString.utf8().data());
>+}
>+
>+void IDBServer::deleteOriginFromDatabase(const String& originIdentifierString)
>+{
>+    ASSERT(!isMainThread());
>+
>+    openQuotaDatabase();
>+    if (!m_quotaDatabase.isOpen())
>+        return;
>+
>+    SQLiteStatement statement(m_quotaDatabase, "DELETE FROM Quota WHERE origin LIKE ?");
>+    if (statement.prepare() != SQLITE_OK) {
>+        LOG_ERROR("Failed to prepare deletion for origin %s in quota database", originIdentifierString.utf8().data());
>+        return;
>+    }
>+    
>+    statement.bindText(1, makeString("%", originIdentifierString));
>+    if (!statement.executeCommand()) {
>+        LOG_ERROR("Failed to execute deletion for origin %s in quota database", originIdentifierString.utf8().data());
>+        return;
>+    }
>+    
>+    mayDeleteQuotaDatabase();
>+}
>+    
>+void IDBServer::mayDeleteQuotaDatabase()
>+{
>+    bool isEmpty = true;
>+    SQLiteStatement statement(m_quotaDatabase, "SELECT quota FROM Quota");
>+    if (statement.prepare() != SQLITE_OK)
>+        LOG_ERROR("Failed to get number of entries in quota database.");
>+    else if (statement.step() == SQLITE_ROW)
>+        isEmpty = false;
>+    
>+    if (isEmpty) {
>+        m_quotaDatabase.close();
>+        SQLiteFileSystem::deleteDatabaseFile(quotaDatabasePath());
>+        SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_databaseDirectoryPath);
>+    }
>+}
>+
>+void IDBServer::mayDeleteOriginFromDatabase(const IDBDatabaseIdentifier& identifier)
>+{
>+    if (!FileSystem::fileExists(identifier.databaseDirectoryRelativeToRoot(m_databaseDirectoryPath)))
>+        deleteOriginFromDatabase(identifier.originString());
>+}
>+
>+void IDBServer::setQuotaForOrigin(const String& originIdentifierString, uint64_t quota)
>+{
>+    ASSERT(isMainThread());
>+
>+    for (auto& databaseIdentifier : m_uniqueIDBDatabaseMap.keys()) {
>+        if (databaseIdentifier.originString() == originIdentifierString)
>+            m_uniqueIDBDatabaseMap.get(databaseIdentifier)->setQuota(quota);
>+    }
>+
>+    postDatabaseTask(createCrossThreadTask(*this, &IDBServer::setQuotaInDatabase, originIdentifierString, quota));
>+}
>+
>+bool IDBServer::isQuotaFullForOrigin(const IDBDatabaseIdentifier& identifier, IDBQuotaDetails& details)
>+{
>+    auto quota = quotaForOrigin(identifier.originString());
>+    auto usage = SQLiteIDBBackingStore::originDiskUsage(identifier.databaseDirectoryRelativeToRoot(m_databaseDirectoryPath));
>+    details = { identifier.databaseName(), identifier.originString(), quota, usage, 0, QuotaIncreaseSize };
>+    return quota <= usage;
>+}
>+
> UniqueIDBDatabase& IDBServer::getOrCreateUniqueIDBDatabase(const IDBDatabaseIdentifier& identifier)
> {
>     ASSERT(isMainThread());
>@@ -126,7 +274,7 @@ std::unique_ptr<IDBBackingStore> IDBServer::createBackingStore(const IDBDatabase
>     if (m_databaseDirectoryPath.isEmpty())
>         return MemoryIDBBackingStore::create(identifier);
> 
>-    return std::make_unique<SQLiteIDBBackingStore>(identifier, m_databaseDirectoryPath, m_backingStoreTemporaryFileHandler, m_perOriginQuota);
>+    return std::make_unique<SQLiteIDBBackingStore>(identifier, m_databaseDirectoryPath, m_backingStoreTemporaryFileHandler, quotaForOrigin(identifier.originString()));
> }
> 
> void IDBServer::openDatabase(const IDBRequestData& requestData)
>@@ -170,6 +318,10 @@ std::unique_ptr<UniqueIDBDatabase> IDBServer::closeAndTakeUniqueIDBDatabase(Uniq
>     ASSERT(isMainThread());
> 
>     auto uniquePointer = m_uniqueIDBDatabaseMap.take(database.identifier());
>+
>+    if (m_uniqueIDBDatabaseMap.isEmpty() && m_quotaDatabase.isOpen())
>+        m_quotaDatabase.close();
>+
>     ASSERT(uniquePointer);
> 
>     return uniquePointer;
>@@ -634,6 +786,8 @@ void IDBServer::performCloseAndDeleteDatabasesForOrigins(const Vector<SecurityOr
>                 originPath = FileSystem::pathByAppendingComponent(topOriginPath, origin.databaseIdentifier());
>                 removeAllDatabasesForOriginPath(originPath, -WallTime::infinity());
>             }
>+
>+            deleteOriginFromDatabase(origin.databaseIdentifier());
>         }
>     }
> 
>diff --git a/Source/WebCore/Modules/indexeddb/server/IDBServer.h b/Source/WebCore/Modules/indexeddb/server/IDBServer.h
>index fa89aa5cc4147377df675e2d7d6c6f709a5eff0a..4fa137d4579774fb0e81cdf94e7efcb18fdcd0f7 100644
>--- a/Source/WebCore/Modules/indexeddb/server/IDBServer.h
>+++ b/Source/WebCore/Modules/indexeddb/server/IDBServer.h
>@@ -29,6 +29,7 @@
> 
> #include "IDBConnectionToClient.h"
> #include "IDBDatabaseIdentifier.h"
>+#include "SQLiteDatabase.h"
> #include "UniqueIDBDatabase.h"
> #include "UniqueIDBDatabaseConnection.h"
> #include <wtf/CrossThreadTaskHandler.h>
>@@ -48,7 +49,7 @@ struct IDBGetRecordData;
> 
> namespace IDBServer {
> 
>-const uint64_t defaultPerOriginQuota = 500 * MB;
>+const uint64_t defaultPerOriginQuota = 5 * MB;
> 
> class IDBBackingStoreTemporaryFileHandler;
> 
>@@ -91,6 +92,11 @@ public:
> 
>     WEBCORE_EXPORT void getAllDatabaseNames(uint64_t serverConnectionIdentifier, const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID);
> 
>+    WEBCORE_EXPORT void setQuotaForOrigin(const String& originString, uint64_t);
>+
>+    void mayDeleteOriginFromDatabase(const IDBDatabaseIdentifier&);
>+    bool isQuotaFullForOrigin(const IDBDatabaseIdentifier&, IDBQuotaDetails&);
>+
>     void postDatabaseTask(CrossThreadTask&&);
>     void postDatabaseTaskReply(CrossThreadTask&&);
> 
>@@ -122,6 +128,13 @@ private:
>     void performCloseAndDeleteDatabasesForOrigins(const Vector<SecurityOriginData>&, uint64_t callbackID);
>     void didPerformCloseAndDeleteDatabases(uint64_t callbackID);
> 
>+    String quotaDatabasePath() const;
>+    void openQuotaDatabase();
>+    uint64_t quotaForOrigin(const String& originString);
>+    void setQuotaInDatabase(const String& originString, uint64_t quota);
>+    void deleteOriginFromDatabase(const String& originString);
>+    void mayDeleteQuotaDatabase();
>+
>     HashMap<uint64_t, RefPtr<IDBConnectionToClient>> m_connectionMap;
>     HashMap<IDBDatabaseIdentifier, std::unique_ptr<UniqueIDBDatabase>> m_uniqueIDBDatabaseMap;
> 
>@@ -134,6 +147,7 @@ private:
>     IDBBackingStoreTemporaryFileHandler& m_backingStoreTemporaryFileHandler;
> 
>     uint64_t m_perOriginQuota { defaultPerOriginQuota };
>+    SQLiteDatabase m_quotaDatabase;
> };
> 
> } // namespace IDBServer
>diff --git a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp
>index a8a48067c0dc677de95b0f63555298d235295060..4f896acc1fd98c4606a7dd94c7c1e0cde5a42686 100644
>--- a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp
>+++ b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp
>@@ -849,20 +849,31 @@ uint64_t SQLiteIDBBackingStore::quotaForOrigin() const
>     return std::min(diskFreeSpaceSize / 2, m_quota);
> }
> 
>+uint64_t SQLiteIDBBackingStore::originDiskUsage(const String& absoluteOriginDirectory)
>+{
>+    uint64_t diskUsage = 0;
>+    for (auto& directory : FileSystem::listDirectory(absoluteOriginDirectory, "*")) {
>+        for (auto& file : FileSystem::listDirectory(directory, "*.sqlite3*"_s))
>+            diskUsage += SQLiteFileSystem::getDatabaseFileSize(file);
>+    }
>+
>+    return diskUsage;
>+}
>+
>+uint64_t SQLiteIDBBackingStore::databaseSize() const
>+{
>+    return SQLiteFileSystem::getDatabaseFileSize(fullDatabasePath());
>+}
>+
> uint64_t SQLiteIDBBackingStore::maximumSize() const
> {
>     ASSERT(!isMainThread());
> 
>     // The maximum size for one database file is the quota for its origin, minus size of all databases within that origin,
>     // and plus current size of the database file.
>-    uint64_t databaseFileSize = SQLiteFileSystem::getDatabaseFileSize(fullDatabasePath());
>+    uint64_t databaseFileSize = databaseSize();
>     uint64_t quota = quotaForOrigin();
>-
>-    uint64_t diskUsage = 0;
>-    for (auto& directory : FileSystem::listDirectory(m_absoluteDatabaseDirectory, "*")) {
>-        for (auto& file : FileSystem::listDirectory(directory, "*.sqlite3"_s))
>-            diskUsage += SQLiteFileSystem::getDatabaseFileSize(file);
>-    }
>+    uint64_t diskUsage = originDiskUsage(m_absoluteDatabaseDirectory);
>     ASSERT(diskUsage >= databaseFileSize);
> 
>     if (quota < diskUsage)
>@@ -897,7 +908,7 @@ IDBError SQLiteIDBBackingStore::beginTransaction(const IDBTransactionInfo& info)
>             || sql.bindText(1, String::number(info.newVersion())) != SQLITE_OK
>             || sql.step() != SQLITE_DONE) {
>             if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                error = IDBError { QuotaExceededError, "Failed to store new database version in database because no enough space for domain"_s };
>+                error = IDBError { QuotaExceededError, "Failed to store new database version in database because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>             else
>                 error = IDBError { UnknownError, "Failed to store new database version in database"_s };
>         }
>@@ -984,7 +995,7 @@ IDBError SQLiteIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t
>             || sql->step() != SQLITE_DONE) {
>             LOG_ERROR("Could not add object store '%s' to ObjectStoreInfo table (%i) - %s", info.name().utf8().data(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>             if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                return IDBError { QuotaExceededError, "Could not create object store because no enough space for domain"_s };
>+                return IDBError { QuotaExceededError, "Could not create object store because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>             return IDBError { UnknownError, "Could not create object store"_s };
>         }
>     }
>@@ -996,7 +1007,7 @@ IDBError SQLiteIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t
>             || sql->step() != SQLITE_DONE) {
>             LOG_ERROR("Could not seed initial key generator value for ObjectStoreInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>             if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                return IDBError { QuotaExceededError, "Could not seed initial key generator value for object store because no enough space for domain"_s };
>+                return IDBError { QuotaExceededError, "Could not seed initial key generator value for object store because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>             return IDBError { UnknownError, "Could not seed initial key generator value for object store"_s };
>         }
>     }
>@@ -1123,7 +1134,7 @@ IDBError SQLiteIDBBackingStore::renameObjectStore(const IDBResourceIdentifier& t
>             || sql->step() != SQLITE_DONE) {
>             LOG_ERROR("Could not update name for object store id %" PRIi64 " in ObjectStoreInfo table (%i) - %s", objectStoreIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>             if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                return IDBError { QuotaExceededError, "Could not rename object store because no enough space for domain"_s };
>+                return IDBError { QuotaExceededError, "Could not rename object store because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>             return IDBError { UnknownError, "Could not rename object store"_s };
>         }
>     }
>@@ -1208,7 +1219,7 @@ IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
>         || sql->step() != SQLITE_DONE) {
>         LOG_ERROR("Could not add index '%s' to IndexInfo table (%i) - %s", info.name().utf8().data(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>         if (m_sqliteDB->lastError() == SQLITE_FULL)
>-            return IDBError { QuotaExceededError, "Unable to create index in database because no enough space for domain"_s };
>+            return IDBError { QuotaExceededError, "Unable to create index in database because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>         return IDBError { UnknownError, "Unable to create index in database"_s };
>     }
> 
>@@ -1352,7 +1363,7 @@ IDBError SQLiteIDBBackingStore::uncheckedPutIndexRecord(int64_t objectStoreID, i
>             || sql->step() != SQLITE_DONE) {
>             LOG_ERROR("Could not put index record for index %" PRIi64 " in object store %" PRIi64 " in Records table (%i) - %s", indexID, objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>             if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                return IDBError { QuotaExceededError, "Error putting index record into database because no enough space for domain"_s };
>+                return IDBError { QuotaExceededError, "Error putting index record into database because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>             return IDBError { UnknownError, "Error putting index record into database"_s };
>         }
>     }
>@@ -1443,7 +1454,7 @@ IDBError SQLiteIDBBackingStore::renameIndex(const IDBResourceIdentifier& transac
>             || sql->step() != SQLITE_DONE) {
>             LOG_ERROR("Could not update name for index id (%" PRIi64 ", %" PRIi64 ") in IndexInfo table (%i) - %s", objectStoreIdentifier, indexIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>             if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                return IDBError { QuotaExceededError, "Could not rename index because no enough space for domain"_s };
>+                return IDBError { QuotaExceededError, "Could not rename index because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>             return IDBError { UnknownError, "Could not rename index"_s };
>         }
>     }
>@@ -1784,7 +1795,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
>             || sql->step() != SQLITE_DONE) {
>             LOG_ERROR("Could not put record for object store %" PRIi64 " in Records table (%i) - %s", objectStoreInfo.identifier(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>             if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                return IDBError { QuotaExceededError, "Unable to store record in object store because no enough space for domain"_s };
>+                return IDBError { QuotaExceededError, "Unable to store record in object store because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>             return IDBError { UnknownError, "Unable to store record in object store"_s };
>         }
> 
>@@ -1818,7 +1829,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
>                 || sql->step() != SQLITE_DONE) {
>                 LOG_ERROR("Unable to record Blob record in database");
>                 if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                    return IDBError { QuotaExceededError, "Unable to record Blob record in database because no enough space for domain"_s };
>+                    return IDBError { QuotaExceededError, "Unable to record Blob record in database because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>                 return IDBError { UnknownError, "Unable to record Blob record in database"_s };
>             }
>         }
>@@ -1853,7 +1864,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
>                 || sql->step() != SQLITE_DONE) {
>                 LOG_ERROR("Unable to record Blob file record in database");
>                 if (m_sqliteDB->lastError() == SQLITE_FULL)
>-                    return IDBError { QuotaExceededError, "Unable to record Blob file in database because no enough space for domain"_s };
>+                    return IDBError { QuotaExceededError, "Unable to record Blob file in database because no enough space for domain"_s, { m_identifier.databaseName(), m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>                 return IDBError { UnknownError, "Unable to record Blob file record in database"_s };
>             }
>         }
>@@ -2392,7 +2403,7 @@ IDBError SQLiteIDBBackingStore::uncheckedSetKeyGeneratorValue(int64_t objectStor
>         || sql->step() != SQLITE_DONE) {
>         LOG_ERROR("Could not update key generator value (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
>         if (m_sqliteDB->lastError() == SQLITE_FULL)
>-            return IDBError { QuotaExceededError, "Error storing new key generator value in database because no enough space for domain"_s };
>+            return IDBError { QuotaExceededError, "Error storing new key generator value in database because no enough space for domain"_s, { m_identifier.databaseName(),  m_identifier.originString(), m_quota, originDiskUsage(m_absoluteDatabaseDirectory), databaseSize(), databaseSize() + QuotaIncreaseSize } };
>         return IDBError { ConstraintError, "Error storing new key generator value in database" };
>     }
> 
>diff --git a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h
>index da67123902ec311317f687d2e01665a5a6284045..6862d9afa34f8b0457ca6f6034b3b9ffc6518078 100644
>--- a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h
>+++ b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h
>@@ -43,6 +43,8 @@ class SQLiteStatement;
> 
> namespace IDBServer {
> 
>+const uint64_t QuotaIncreaseSize = 5 * MB;
>+
> class SQLiteIDBCursor;
> 
> class SQLiteIDBBackingStore : public IDBBackingStore {
>@@ -95,12 +97,15 @@ public:
> 
>     static String databaseNameFromEncodedFilename(const String&);
> 
>+    static uint64_t originDiskUsage(const String&);
>+
> private:
>     String filenameForDatabaseName() const;
>     String fullDatabasePath() const;
> 
>     uint64_t quotaForOrigin() const;
>     uint64_t maximumSize() const;
>+    uint64_t databaseSize() const;
> 
>     bool ensureValidRecordsTable();
>     bool ensureValidIndexRecordsTable();
>diff --git a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp b/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp
>index fc07ef1451b97e075cd3a56f620093a349c0cbc9..caa0b5eae0d76790d33680b7c695ef02371edff3 100644
>--- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp
>+++ b/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp
>@@ -256,6 +256,7 @@ void UniqueIDBDatabase::deleteBackingStore(const IDBDatabaseIdentifier& identifi
>         deletedVersion = databaseInfo.version();
>         backingStore->deleteBackingStore();
>     }
>+    m_server.mayDeleteOriginFromDatabase(m_identifier);
> 
>     postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteBackingStore, deletedVersion));
> }
>@@ -612,12 +613,20 @@ void UniqueIDBDatabase::openBackingStore(const IDBDatabaseIdentifier& identifier
>     LOG(IndexedDB, "(db) UniqueIDBDatabase::openBackingStore (%p)", this);
> 
>     ASSERT(!m_backingStore);
>-    m_backingStore = m_server.createBackingStore(identifier);
>-    m_backingStoreSupportsSimultaneousTransactions = m_backingStore->supportsSimultaneousTransactions();
>-    m_backingStoreIsEphemeral = m_backingStore->isEphemeral();
> 
>+    // Check if there is space for new database.
>+    IDBError error;
>+    IDBQuotaDetails details;
>     IDBDatabaseInfo databaseInfo;
>-    auto error = m_backingStore->getOrEstablishDatabaseInfo(databaseInfo);
>+    if (m_server.isQuotaFullForOrigin(identifier, details))
>+        error = IDBError { QuotaExceededError, "Failed to create new database because no enough space for domain"_s, details };
>+    else {
>+        m_backingStore = m_server.createBackingStore(identifier);
>+        m_backingStoreSupportsSimultaneousTransactions = m_backingStore->supportsSimultaneousTransactions();
>+        m_backingStoreIsEphemeral = m_backingStore->isEphemeral();
>+
>+        error = m_backingStore->getOrEstablishDatabaseInfo(databaseInfo);
>+    }
> 
>     postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenBackingStore, databaseInfo, error));
> }
>@@ -1921,6 +1930,12 @@ void UniqueIDBDatabase::forgetErrorCallback(uint64_t callbackIdentifier)
> 
> void UniqueIDBDatabase::setQuota(uint64_t quota)
> {
>+    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performSetQuota, quota));
>+}
>+    
>+void UniqueIDBDatabase::performSetQuota(uint64_t quota)
>+{
>+    ASSERT(!isMainThread());
>     if (m_backingStore)
>         m_backingStore->setQuota(quota);
> }
>diff --git a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h b/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h
>index d46dfa903cfb35ed7c3538e21c3e2d6c4ab87480..0bb32421b71ffde98bb7189ce784e7d8010a76bb 100644
>--- a/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h
>+++ b/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h
>@@ -167,6 +167,8 @@ private:
>     void performUnconditionalDeleteBackingStore();
>     void shutdownForClose();
> 
>+    void performSetQuota(uint64_t quota);
>+
>     // Main thread callbacks
>     void didDeleteBackingStore(uint64_t deletedVersion);
>     void didOpenBackingStore(const IDBDatabaseInfo&, const IDBError&);
>diff --git a/Source/WebCore/Modules/indexeddb/shared/IDBError.cpp b/Source/WebCore/Modules/indexeddb/shared/IDBError.cpp
>index ae314b24ee72caa0969e6c3b9b6e76e9acac3398..9d78b0de735d2a58cc2f6b75feeaa5e62c9b4a1f 100644
>--- a/Source/WebCore/Modules/indexeddb/shared/IDBError.cpp
>+++ b/Source/WebCore/Modules/indexeddb/shared/IDBError.cpp
>@@ -32,21 +32,23 @@
> 
> namespace WebCore {
> 
>-IDBError::IDBError(std::optional<ExceptionCode> code, const String& message)
>+IDBError::IDBError(std::optional<ExceptionCode> code, const String& message, const IDBQuotaDetails& details)
>     : m_code(code)
>     , m_message(message)
>+    , m_quotaDetails(details)
> {
> }
> 
> IDBError IDBError::isolatedCopy() const
> {
>-    return IDBError { m_code, m_message.isolatedCopy() };
>+    return IDBError { m_code, m_message.isolatedCopy(), m_quotaDetails.isolatedCopy() };
> }
> 
> IDBError& IDBError::operator=(const IDBError& other)
> {
>     m_code = other.m_code;
>     m_message = other.m_message;
>+    m_quotaDetails = other.m_quotaDetails;
>     return *this;
> }
> 
>diff --git a/Source/WebCore/Modules/indexeddb/shared/IDBError.h b/Source/WebCore/Modules/indexeddb/shared/IDBError.h
>index 0a28967b169565d04c639043969dd8e770dccb33..d5f31a81b424b2a1474a8db97d5d1b1e7f6131b1 100644
>--- a/Source/WebCore/Modules/indexeddb/shared/IDBError.h
>+++ b/Source/WebCore/Modules/indexeddb/shared/IDBError.h
>@@ -29,13 +29,14 @@
> 
> #include "DOMException.h"
> #include "ExceptionCode.h"
>+#include "IDBQuotaDetails.h"
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
> 
> class IDBError {
> public:
>-    WEBCORE_EXPORT explicit IDBError(std::optional<ExceptionCode> = std::nullopt, const String& message = { });
>+    WEBCORE_EXPORT explicit IDBError(std::optional<ExceptionCode> = std::nullopt, const String& message = { }, const IDBQuotaDetails& details = { });
> 
>     static IDBError userDeleteError()
>     {
>@@ -54,6 +55,7 @@ public:
>     std::optional<ExceptionCode> code() const { return m_code; }
>     String name() const;
>     String message() const;
>+    IDBQuotaDetails quotaDetails() const { return m_quotaDetails; };
> 
>     bool isNull() const { return !m_code; }
> 
>@@ -65,6 +67,7 @@ public:
> private:
>     std::optional<ExceptionCode> m_code;
>     String m_message;
>+    IDBQuotaDetails m_quotaDetails;
> };
> 
> template<class Encoder>
>@@ -75,7 +78,7 @@ void IDBError::encode(Encoder& encoder) const
>         encoder.encodeEnum(m_code.value());
>     } else
>         encoder << false;
>-    encoder << m_message;
>+    encoder << m_message << m_quotaDetails;
> }
>     
> template<class Decoder>
>@@ -96,6 +99,9 @@ bool IDBError::decode(Decoder& decoder, IDBError& error)
>     if (!decoder.decode(error.m_message))
>         return false;
> 
>+    if (!decoder.decode(error.m_quotaDetails))
>+        return false;
>+
>     return true;
> }
> 
>diff --git a/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp b/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp
>index 61aeb8f7d70151b942285acdccf81bfb1ea42626..26c41d536b96f19cc3e298628797320b9bd15ff5 100644
>--- a/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp
>+++ b/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp
>@@ -446,6 +446,12 @@ void InProcessIDBServer::accessToTemporaryFileComplete(const String& path)
>     FileSystem::deleteFile(path);
> }
> 
>+void InProcessIDBServer::updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota)
>+{
>+    UNUSED_PARAM(originIdentifierString);
>+    UNUSED_PARAM(quota);
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.h b/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.h
>index c7944d1b36f7359d3cb617069c30121885534973..2c2ac7f3c8eb1c3c2e88c4063631ef5301d7d347 100644
>--- a/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.h
>+++ b/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.h
>@@ -82,6 +82,7 @@ public:
>     void openDBRequestCancelled(const IDBRequestData&) final;
>     void confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier) final;
>     void getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID) final;
>+    void updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota) final;
> 
>     // IDBConnectionToClient
>     uint64_t identifier() const override;
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 3bfee9bca336d9ec470df2867a933d7772abbc73..5be8dcbb69fe4387c4ed8d5b3114008085817d6b 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -4013,6 +4013,7 @@
> 		C9D851F01B39DC780085062E /* MediaSessionMetadata.h in Headers */ = {isa = PBXBuildFile; fileRef = C9D851EE1B39DC780085062E /* MediaSessionMetadata.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		C9F87CFE1B28F40E00979B83 /* MediaSessionEvents.h in Headers */ = {isa = PBXBuildFile; fileRef = C9F87CFD1B28E5F600979B83 /* MediaSessionEvents.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		CA3BF67E10D99BAE00E6CE53 /* ScrollAnimator.h in Headers */ = {isa = PBXBuildFile; fileRef = CA3BF67D10D99BAE00E6CE53 /* ScrollAnimator.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		CA69902421BEE64F00E13B7B /* IDBQuotaDetails.h in Headers */ = {isa = PBXBuildFile; fileRef = CA69902221BEE62C00E13B7B /* IDBQuotaDetails.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		CAE9F910146441F000C245B0 /* CSSAspectRatioValue.h in Headers */ = {isa = PBXBuildFile; fileRef = CAE9F90E146441F000C245B0 /* CSSAspectRatioValue.h */; };
> 		CB38FD521CCF939400592A3F /* JSPerformanceEntry.h in Headers */ = {isa = PBXBuildFile; fileRef = CB38FD4E1CCF937E00592A3F /* JSPerformanceEntry.h */; };
> 		CB38FD5B1CD2325B00592A3F /* JSPerformanceResourceTiming.h in Headers */ = {isa = PBXBuildFile; fileRef = CB38FD591CD2314500592A3F /* JSPerformanceResourceTiming.h */; };
>@@ -13304,6 +13305,7 @@
> 		CA1635DC2072E76900E7D2CE /* ReferrerPolicy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ReferrerPolicy.cpp; sourceTree = "<group>"; };
> 		CA3BF67B10D99BAE00E6CE53 /* ScrollAnimator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ScrollAnimator.cpp; sourceTree = "<group>"; };
> 		CA3BF67D10D99BAE00E6CE53 /* ScrollAnimator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollAnimator.h; sourceTree = "<group>"; };
>+		CA69902221BEE62C00E13B7B /* IDBQuotaDetails.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBQuotaDetails.h; sourceTree = "<group>"; };
> 		CAE9F90D146441F000C245B0 /* CSSAspectRatioValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSAspectRatioValue.cpp; sourceTree = "<group>"; };
> 		CAE9F90E146441F000C245B0 /* CSSAspectRatioValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSAspectRatioValue.h; sourceTree = "<group>"; };
> 		CB38FD4A1CCCF2DD00592A3F /* PerformanceEntry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PerformanceEntry.cpp; sourceTree = "<group>"; };
>@@ -18200,6 +18202,7 @@
> 				51E269351DD3BD91006B6A58 /* IDBIterateCursorData.h */,
> 				5160712C1BD8307200DBC4F2 /* IDBObjectStoreInfo.cpp */,
> 				5160712D1BD8307200DBC4F2 /* IDBObjectStoreInfo.h */,
>+				CA69902221BEE62C00E13B7B /* IDBQuotaDetails.h */,
> 				510A58F51BACC4A500C19282 /* IDBRequestData.cpp */,
> 				510A58F61BACC4A500C19282 /* IDBRequestData.h */,
> 				5145B1071BC4890B00E86219 /* IDBResourceIdentifier.cpp */,
>@@ -28959,6 +28962,7 @@
> 				5185FCA01BB4C4E80012898F /* IDBObjectStore.h in Headers */,
> 				5160712F1BD8307800DBC4F2 /* IDBObjectStoreInfo.h in Headers */,
> 				5185FCA41BB4C4E80012898F /* IDBOpenDBRequest.h in Headers */,
>+				CA69902421BEE64F00E13B7B /* IDBQuotaDetails.h in Headers */,
> 				5185FCA71BB4C4E80012898F /* IDBRecordIdentifier.h in Headers */,
> 				5185FCA91BB4C4E80012898F /* IDBRequest.h in Headers */,
> 				514129991C6976900059E714 /* IDBRequestCompletionEvent.h in Headers */,
>@@ -29984,7 +29988,6 @@
> 				11310CF620BA4A560065A8D0 /* LayoutChildIterator.h in Headers */,
> 				1199FA46208E35A3002358CC /* LayoutContainer.h in Headers */,
> 				11310CF520BA4A4C0065A8D0 /* LayoutDescendantIterator.h in Headers */,
>-				6F7CA3C6208C2957002F29AB /* LayoutState.h in Headers */,
> 				1199FA53208E38D3002358CC /* LayoutInlineBox.h in Headers */,
> 				1199FA4F208E3899002358CC /* LayoutInlineContainer.h in Headers */,
> 				11310CF420BA4A3D0065A8D0 /* LayoutIterator.h in Headers */,
>@@ -29995,7 +29998,7 @@
> 				A12538D413F9B60A00024754 /* LayoutRepainter.h in Headers */,
> 				11310CF320BA4A370065A8D0 /* LayoutReplaced.h in Headers */,
> 				141DC054164834B900371E5A /* LayoutSize.h in Headers */,
>-				2D9066070BE141D400956998 /* RenderLayoutState.h in Headers */,
>+				6F7CA3C6208C2957002F29AB /* LayoutState.h in Headers */,
> 				11310CF220BA4A320065A8D0 /* LayoutTreeBuilder.h in Headers */,
> 				141DC0481648348F00371E5A /* LayoutUnit.h in Headers */,
> 				CDE8B5ED1A69777300B4B66A /* LegacyCDMPrivateClearKey.h in Headers */,
>@@ -30597,6 +30600,7 @@
> 				0F580CFF0F12DE9B0051D689 /* RenderLayerBacking.h in Headers */,
> 				0F580CFD0F12DE9B0051D689 /* RenderLayerCompositor.h in Headers */,
> 				3C244FEAA375AC633F88BE6F /* RenderLayerModelObject.h in Headers */,
>+				2D9066070BE141D400956998 /* RenderLayoutState.h in Headers */,
> 				0BE030A20F3112FB003C1A46 /* RenderLineBoxList.h in Headers */,
> 				BCEA4864097D93020094C9E4 /* RenderLineBreak.h in Headers */,
> 				ABB5419F0ACDDFE4002820EB /* RenderListBox.h in Headers */,
>diff --git a/Source/WebCore/loader/EmptyClients.h b/Source/WebCore/loader/EmptyClients.h
>index ae588f784d204aa95b276cc7a3250728c7f7b614..5735ceed34e30d11e58f976d69030c7902038e25 100644
>--- a/Source/WebCore/loader/EmptyClients.h
>+++ b/Source/WebCore/loader/EmptyClients.h
>@@ -124,6 +124,7 @@ class EmptyChromeClient : public ChromeClient {
>     void print(Frame&) final { }
> 
>     void exceededDatabaseQuota(Frame&, const String&, DatabaseDetails) final { }
>+    uint64_t exceededDatabaseQuota(Frame&, IDBQuotaDetails) final { return 0; }
> 
>     void reachedMaxAppCacheSize(int64_t) final { }
>     void reachedApplicationCacheOriginQuota(SecurityOrigin&, int64_t) final { }
>diff --git a/Source/WebCore/page/ChromeClient.h b/Source/WebCore/page/ChromeClient.h
>index 08f583e2ece9606d6e4e0f019f8416b4f8994ff1..68406bfd02caa43945213c2f3badd1a56932f4ad 100644
>--- a/Source/WebCore/page/ChromeClient.h
>+++ b/Source/WebCore/page/ChromeClient.h
>@@ -33,6 +33,7 @@
> #include "GraphicsLayer.h"
> #include "HTMLMediaElementEnums.h"
> #include "HostWindow.h"
>+#include "IDBQuotaDetails.h"
> #include "Icon.h"
> #include "LayerFlushThrottleState.h"
> #include "MediaProducer.h"
>@@ -209,6 +210,7 @@ public:
>     virtual void pageExtendedBackgroundColorDidChange(Color) const { }
> 
>     virtual void exceededDatabaseQuota(Frame&, const String& databaseName, DatabaseDetails) = 0;
>+    virtual uint64_t exceededDatabaseQuota(Frame&, IDBQuotaDetails) = 0;
> 
>     // Callback invoked when the application cache fails to save a cache object
>     // because storing it would grow the database file past its defined maximum
>diff --git a/Source/WebCore/page/SecurityOriginData.cpp b/Source/WebCore/page/SecurityOriginData.cpp
>index b7f83cee2674d55acfcc98e9e1139a407151a0a6..23b51fe7a031bba8a47a3559e3387ed585b4401f 100644
>--- a/Source/WebCore/page/SecurityOriginData.cpp
>+++ b/Source/WebCore/page/SecurityOriginData.cpp
>@@ -64,6 +64,7 @@ Ref<SecurityOrigin> SecurityOriginData::securityOrigin() const
> }
> 
> static const char separatorCharacter = '_';
>+static const char separatorCharacterForOrigins = '/';
> 
> String SecurityOriginData::databaseIdentifier() const
> {
>@@ -120,6 +121,15 @@ std::optional<SecurityOriginData> SecurityOriginData::fromDatabaseIdentifier(con
>     return SecurityOriginData { protocol, host, static_cast<uint16_t>(port) };
> }
> 
>+std::optional<SecurityOriginData> SecurityOriginData::fromOriginIdentifier(const String& originIdentifier)
>+{
>+    auto seperator = originIdentifier.find(separatorCharacterForOrigins);
>+    if (seperator != notFound)
>+        return fromDatabaseIdentifier(originIdentifier.substring(0, seperator));
>+    
>+    return fromDatabaseIdentifier(originIdentifier);
>+}
>+
> SecurityOriginData SecurityOriginData::isolatedCopy() const
> {
>     SecurityOriginData result;
>diff --git a/Source/WebCore/page/SecurityOriginData.h b/Source/WebCore/page/SecurityOriginData.h
>index 27762ea21d6d2065e9dd0146db979b332ec456c0..fbb0842768b1c5e96a2c9498582749cec50b3970 100644
>--- a/Source/WebCore/page/SecurityOriginData.h
>+++ b/Source/WebCore/page/SecurityOriginData.h
>@@ -70,6 +70,7 @@ struct SecurityOriginData {
>     // file names. This format should be used in storage APIs only.
>     WEBCORE_EXPORT String databaseIdentifier() const;
>     WEBCORE_EXPORT static std::optional<SecurityOriginData> fromDatabaseIdentifier(const String&);
>+    WEBCORE_EXPORT static std::optional<SecurityOriginData> fromOriginIdentifier(const String&);
>     
>     template<class Encoder> void encode(Encoder&) const;
>     template<class Decoder> static std::optional<SecurityOriginData> decode(Decoder&);
>diff --git a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
>index 1fe1189c018f508f9f3f0061397555a2ac2953eb..effb35c297356bbb09d3096cee53ebfbed74fbfa 100644
>--- a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
>+++ b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
>@@ -359,6 +359,11 @@ void WebIDBConnectionToClient::getAllDatabaseNames(uint64_t serverConnectionIden
>     NetworkProcess::singleton().idbServer(m_sessionID).getAllDatabaseNames(serverConnectionIdentifier, topOrigin, openingOrigin, callbackID);
> }
> 
>+void WebIDBConnectionToClient::updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).setQuotaForOrigin(originIdentifierString, quota);
>+}
>+
> } // namespace WebKit
> 
> #endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h
>index 5926b00213a72b3073f2c047c60b1ec4449c7f80..9bf908876167bd0b45e02c6529697b28ef4c6a31 100644
>--- a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h
>+++ b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h
>@@ -121,6 +121,8 @@ public:
> 
>     void getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID);
> 
>+    void updateQuotaForOrigin(const String& originIdentifierString, uint64_t quota);
>+
>     void disconnectedFromWebProcess();
> 
>     void didReceiveMessage(IPC::Connection&, IPC::Decoder&);
>diff --git a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in
>index 4aab0267d7b354326c57749e070082eeb83770f1..6805abe2cea4aaa92931af9223ce43e70510ec9d 100644
>--- a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in
>+++ b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in
>@@ -52,5 +52,6 @@ messages -> WebIDBConnectionToClient {
>     ConfirmDidCloseFromServer(uint64_t databaseConnectionIdentifier);
> 
>     GetAllDatabaseNames(uint64_t serverConnectionIdentifier, struct WebCore::SecurityOriginData topOrigin, struct WebCore::SecurityOriginData openingOrigin, uint64_t callbackID);
>+    UpdateQuotaForOrigin(String originIdentifier, uint64_t quota);
> }
> #endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.cpp b/Source/WebKit/UIProcess/WebPageProxy.cpp
>index 76a9653f4bd0236fa32bb342c4aa6eb85220a2d9..70cfbbf70f6bb5a449eb3632d64e0401db5735a8 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebPageProxy.cpp
>@@ -6665,7 +6665,7 @@ void WebPageProxy::exceededDatabaseQuota(uint64_t frameID, const String& originI
>         WebFrameProxy* frame = m_process->webFrame(record->frameID);
>         MESSAGE_CHECK(frame);
> 
>-        auto origin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(record->originIdentifier)->securityOrigin());
>+        auto origin = API::SecurityOrigin::create(SecurityOriginData::fromOriginIdentifier(record->originIdentifier)->securityOrigin());
>         m_uiClient->exceededDatabaseQuota(this, frame, origin.ptr(), record->databaseName, record->displayName, record->currentQuota, record->currentOriginUsage, record->currentDatabaseUsage, record->expectedUsage, WTFMove(record->reply));
>         record = records.next();
>     }
>diff --git a/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp b/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp
>index 42e73c8225da91f00b8f1f4e6bf93de074658d1f..d2fd34e6162e5c9d20209230674705a780d9dca1 100644
>--- a/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp
>+++ b/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp
>@@ -219,6 +219,11 @@ void WebIDBConnectionToServer::getAllDatabaseNames(const WebCore::SecurityOrigin
>     send(Messages::WebIDBConnectionToClient::GetAllDatabaseNames(m_identifier, topOrigin, openingOrigin, callbackID));
> }
> 
>+void WebIDBConnectionToServer::updateQuotaForOrigin(const String& originIdentifier, uint64_t quota)
>+{
>+    send(Messages::WebIDBConnectionToClient::UpdateQuotaForOrigin(originIdentifier, quota));
>+}
>+
> void WebIDBConnectionToServer::didDeleteDatabase(const IDBResultData& result)
> {
>     m_connectionToServer->didDeleteDatabase(result);
>diff --git a/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h b/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h
>index 8fe9cb9c0c0402831c98e0f6d0ce67f0eb144200..ef4d0d5d7318ec5ce721174b9222bd3585f25447 100644
>--- a/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h
>+++ b/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h
>@@ -76,6 +76,8 @@ public:
> 
>     void getAllDatabaseNames(const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID) final;
> 
>+    void updateQuotaForOrigin(const String& originIdentifier, uint64_t quota) final;
>+
>     void ref() override { RefCounted<WebIDBConnectionToServer>::ref(); }
>     void deref() override { RefCounted<WebIDBConnectionToServer>::deref(); }
> 
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>index b31b117f0edab398b25124064e16227faf786255..8b0324b86e661522ec2d24c0aff4334c137f6d3d 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>@@ -730,6 +730,21 @@ void WebChromeClient::exceededDatabaseQuota(Frame& frame, const String& database
>     tracker.setQuota(originData, newQuota);
> }
> 
>+uint64_t WebChromeClient::exceededDatabaseQuota(Frame& frame, IDBQuotaDetails details)
>+{
>+    WebFrame* webFrame = WebFrame::fromCoreFrame(frame);
>+    ASSERT(webFrame);
>+
>+    uint64_t newQuota = 0;
>+    RefPtr<API::SecurityOrigin> securityOrigin = API::SecurityOrigin::create(SecurityOriginData::fromOriginIdentifier(details.origin())->securityOrigin());
>+    newQuota = m_page.injectedBundleUIClient().didExceedDatabaseQuota(&m_page, securityOrigin.get(), details.databaseName(), details.databaseName(), details.quota(),  details.usage(), details.databaseUsage(), details.expectedDatabaseUsage());
>+
>+    if (!newQuota)
>+        WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebPageProxy::ExceededDatabaseQuota(webFrame->frameID(), details.origin(), details.databaseName(), details.databaseName(), details.quota(), details.usage(), details.databaseUsage(), details.expectedDatabaseUsage()), Messages::WebPageProxy::ExceededDatabaseQuota::Reply(newQuota), m_page.pageID(), Seconds::infinity(), IPC::SendSyncOption::InformPlatformProcessWillSuspend);
>+    
>+    return newQuota;
>+}
>+
> void WebChromeClient::reachedMaxAppCacheSize(int64_t)
> {
>     notImplemented();
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.h b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.h
>index 4315126b0648e3447fc0b9cfbc88023c001bfca9..3fbba1135e0da963d9422312e4bcac19919503ce 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.h
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.h
>@@ -131,6 +131,7 @@ private:
>     void print(WebCore::Frame&) final;
> 
>     void exceededDatabaseQuota(WebCore::Frame&, const String& databaseName, WebCore::DatabaseDetails) final;
>+    uint64_t exceededDatabaseQuota(WebCore::Frame&, WebCore::IDBQuotaDetails) final;
> 
>     void reachedMaxAppCacheSize(int64_t spaceNeeded) final;
>     void reachedApplicationCacheOriginQuota(WebCore::SecurityOrigin&, int64_t spaceNeeded) final;
>diff --git a/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.h b/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.h
>index 37a32f87687164f039be98b3d0e7e72635a1a8d9..4b3f1e430be54c88d827dd7fd45ded962c7eeba3 100644
>--- a/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.h
>+++ b/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.h
>@@ -118,6 +118,7 @@ private:
> 
>     void print(WebCore::Frame&) final;
>     void exceededDatabaseQuota(WebCore::Frame&, const String& databaseName, WebCore::DatabaseDetails) final;
>+    uint64_t exceededDatabaseQuota(WebCore::Frame&, WebCore::IDBQuotaDetails) final;
>     void reachedMaxAppCacheSize(int64_t spaceNeeded) final;
>     void reachedApplicationCacheOriginQuota(WebCore::SecurityOrigin&, int64_t totalSpaceNeeded) final;
> 
>diff --git a/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.mm b/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.mm
>index 4c5d18dc02ccff2b7eab98050921a67a98f69cc5..6c19e018c88902eed1c0dc1d03fedde0803b5dc9 100644
>--- a/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.mm
>+++ b/Source/WebKitLegacy/mac/WebCoreSupport/WebChromeClient.mm
>@@ -687,6 +687,17 @@ void WebChromeClient::exceededDatabaseQuota(Frame& frame, const String& database
>     END_BLOCK_OBJC_EXCEPTIONS;
> }
> 
>+uint64_t WebChromeClient::exceededDatabaseQuota(Frame& frame, WebCore::IDBQuotaDetails detail)
>+{
>+    BEGIN_BLOCK_OBJC_EXCEPTIONS;
>+    
>+    WebSecurityOrigin *webOrigin = [[WebSecurityOrigin alloc] _initWithWebCoreSecurityOrigin:&frame.document()->securityOrigin()];
>+    CallUIDelegate(m_webView, @selector(webView:frame:exceededDatabaseQuotaForSecurityOrigin:database:), kit(&frame), webOrigin, (NSString *)detail.databaseName());
>+    [webOrigin release];
>+    
>+    END_BLOCK_OBJC_EXCEPTIONS;
>+}
>+
> void WebChromeClient::reachedMaxAppCacheSize(int64_t spaceNeeded)
> {
>     // FIXME: Free some space.
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 202893917e53d9aaa0af273fc573667ad8a8ea56..df6d7c691f303fa0e9c4a593e753f14dd6d2c1b5 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,36 @@
>+2018-12-10  Sihui Liu  <sihui_liu@apple.com>
>+
>+        IndexedDB: quota should be able to increase
>+        https://bugs.webkit.org/show_bug.cgi?id=192556
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * storage/indexeddb/open-twice-workers.html:
>+        * storage/indexeddb/pending-activity-workers.html:
>+        * storage/indexeddb/pending-version-change-on-exit.html:
>+        * storage/indexeddb/pending-version-change-stuck.html:
>+        * storage/indexeddb/resources/exceptions.js:
>+        * storage/indexeddb/resources/instanceof-iframe.js:
>+        * storage/indexeddb/resources/open-during-transaction.js:
>+        * storage/indexeddb/resources/opencursor-key.js:
>+        * storage/indexeddb/resources/optional-arguments.js:
>+        * storage/indexeddb/resources/persistence.js:
>+        * storage/indexeddb/resources/prefetch-bugfix-108071.js:
>+        * storage/indexeddb/resources/prefetch-invalidation.js:
>+        * storage/indexeddb/resources/prefetch-race.js:
>+        * storage/indexeddb/resources/primary-key-unique-to-objectstore.js:
>+        * storage/indexeddb/resources/storage-limit.js:
>+        (test):
>+        (cleanOpenDatabase):
>+        (openDatabase):
>+        (onOpenError):
>+        (onOpenSuccess):
>+        (onAddError):
>+        (prepareDatabase): Deleted.
>+        (onOpenSuccess.request.onerror): Deleted.
>+        (onOpenSuccess.request.onsuccess): Deleted.
>+        * storage/indexeddb/storage-limit-expected.txt:
>+
> 2018-12-09  Commit Queue  <commit-queue@webkit.org>
> 
>         Unreviewed, rolling out r239010.
>diff --git a/LayoutTests/storage/indexeddb/open-twice-workers.html b/LayoutTests/storage/indexeddb/open-twice-workers.html
>index 84d78c54f8190ad30efbaffdf4fb884cfd9fd336..d253c2b133550c2ca3b9808ccf4c46a8ba9636f9 100644
>--- a/LayoutTests/storage/indexeddb/open-twice-workers.html
>+++ b/LayoutTests/storage/indexeddb/open-twice-workers.html
>@@ -7,6 +7,10 @@
> <script>
> if (window.internals)
>     window.internals.settings.setIndexedDBWorkersEnabled(true);
>+
>+if (window.testRunner)
>+    window.testRunner.clearAllDatabases();
>+
> worker = startWorker('resources/open-twice.js');
> </script>
> </body>
>diff --git a/LayoutTests/storage/indexeddb/pending-activity-workers.html b/LayoutTests/storage/indexeddb/pending-activity-workers.html
>index 52e5890ee56cdd0087bf0eaf71bd04b9b4cd8114..2bdb7065bd5346b290516f475a4b542480d0e92b 100644
>--- a/LayoutTests/storage/indexeddb/pending-activity-workers.html
>+++ b/LayoutTests/storage/indexeddb/pending-activity-workers.html
>@@ -5,6 +5,10 @@
> <script>
> if (window.internals)
>     window.internals.settings.setIndexedDBWorkersEnabled(true);
>+
>+if (window.testRunner)
>+    window.testRunner.clearAllDatabases();
>+
> worker = startWorker('resources/pending-activity.js');
> </script>
> </body>
>diff --git a/LayoutTests/storage/indexeddb/pending-version-change-on-exit.html b/LayoutTests/storage/indexeddb/pending-version-change-on-exit.html
>index 94226c99179644dd0f506e60904b740d409881d0..02d58259c06937d5f659696e0b593e028d049203 100644
>--- a/LayoutTests/storage/indexeddb/pending-version-change-on-exit.html
>+++ b/LayoutTests/storage/indexeddb/pending-version-change-on-exit.html
>@@ -8,6 +8,9 @@
> if (window.internals)
>     window.internals.settings.setIndexedDBWorkersEnabled(true);
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("No crashes when there are event listeners in a worker on shutdown");
> 
> if (self.location.search == "?second") {
>diff --git a/LayoutTests/storage/indexeddb/pending-version-change-stuck.html b/LayoutTests/storage/indexeddb/pending-version-change-stuck.html
>index 1f01283d3f9fabc2744fea5b9bb29c371ce0274c..66419fe1dac15dcf5c6c40f8724e9f70fc6e62cd 100644
>--- a/LayoutTests/storage/indexeddb/pending-version-change-stuck.html
>+++ b/LayoutTests/storage/indexeddb/pending-version-change-stuck.html
>@@ -8,6 +8,9 @@
> if (window.internals)
>     window.internals.settings.setIndexedDBWorkersEnabled(true);
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Implicitly terminating worker with blocked setVersion call should allow later open calls to proceed");
> 
> function test()
>diff --git a/LayoutTests/storage/indexeddb/resources/exceptions.js b/LayoutTests/storage/indexeddb/resources/exceptions.js
>index ed67dc0f924fabc52708229999cedc91601c8cf4..fe40b67882eb40abbc329214373caa2e22d8b940 100644
>--- a/LayoutTests/storage/indexeddb/resources/exceptions.js
>+++ b/LayoutTests/storage/indexeddb/resources/exceptions.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Test that expected exceptions are thrown per IndexedDB spec.");
> 
> indexedDBTest(prepareDatabase, testDatabase);
>diff --git a/LayoutTests/storage/indexeddb/resources/instanceof-iframe.js b/LayoutTests/storage/indexeddb/resources/instanceof-iframe.js
>index 6317bab10f1cff98544214a3edfd2dae0bc79efa..9f9912e825b8b1950b9a1a5dd215b3445d4e8300 100644
>--- a/LayoutTests/storage/indexeddb/resources/instanceof-iframe.js
>+++ b/LayoutTests/storage/indexeddb/resources/instanceof-iframe.js
>@@ -1,3 +1,6 @@
>+if (window.testRunner)
>+    testRunner.clearAllDatabases();
>+
> function test(callback) {
>     isMainFrame = self == top;
>     if (isMainFrame)
>diff --git a/LayoutTests/storage/indexeddb/resources/open-during-transaction.js b/LayoutTests/storage/indexeddb/resources/open-during-transaction.js
>index 19a56a75ccf2c0424e5bdecac715ef95f02a6583..291ed300349aab600c714f32dd73166b464e4137 100644
>--- a/LayoutTests/storage/indexeddb/resources/open-during-transaction.js
>+++ b/LayoutTests/storage/indexeddb/resources/open-during-transaction.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Test IndexedDB opening database connections during transactions");
> 
> indexedDBTest(prepareDatabase, startTransaction);
>diff --git a/LayoutTests/storage/indexeddb/resources/opencursor-key.js b/LayoutTests/storage/indexeddb/resources/opencursor-key.js
>index 882b4884116b9f46ceef3478b86078b2f363a1d4..2e8e769c970b633c4671ae5b9b842ab155474d96 100644
>--- a/LayoutTests/storage/indexeddb/resources/opencursor-key.js
>+++ b/LayoutTests/storage/indexeddb/resources/opencursor-key.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Test openCursor/openKeyCursor with raw IDBKeys.");
> 
> var objectStoreData = [
>diff --git a/LayoutTests/storage/indexeddb/resources/optional-arguments.js b/LayoutTests/storage/indexeddb/resources/optional-arguments.js
>index caf402df9bb0398e6e3d526d71c4b4c6eb7067e0..d4259d709d26908fac4216b3fa502c080c6b356f 100644
>--- a/LayoutTests/storage/indexeddb/resources/optional-arguments.js
>+++ b/LayoutTests/storage/indexeddb/resources/optional-arguments.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Exercise optional arguments with missing vs. undefined in IndexedDB methods.");
> 
> indexedDBTest(prepareDatabase, checkOptionalArguments);
>diff --git a/LayoutTests/storage/indexeddb/resources/persistence.js b/LayoutTests/storage/indexeddb/resources/persistence.js
>index 568c08cde3b28d27ac3b292da69704dab8efebc7..1f3e5a42bbd7f5ed622a622c73fb2f991ffa3f2f 100644
>--- a/LayoutTests/storage/indexeddb/resources/persistence.js
>+++ b/LayoutTests/storage/indexeddb/resources/persistence.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Test IndexedDB persistence");
> 
> indexedDBTest(prepareDatabase, unexpectedSuccessCallback);
>diff --git a/LayoutTests/storage/indexeddb/resources/prefetch-bugfix-108071.js b/LayoutTests/storage/indexeddb/resources/prefetch-bugfix-108071.js
>index 126a5f784d1a78067353668704c65380b3425398..78ad336ec18e6002623a058281b6b6bfb155b4c1 100644
>--- a/LayoutTests/storage/indexeddb/resources/prefetch-bugfix-108071.js
>+++ b/LayoutTests/storage/indexeddb/resources/prefetch-bugfix-108071.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Regression test for http://crbug.com/108071");
> 
> // Have to be at least 5 here: 1 initial, 3 continues to trigger prefetch and 1
>diff --git a/LayoutTests/storage/indexeddb/resources/prefetch-invalidation.js b/LayoutTests/storage/indexeddb/resources/prefetch-invalidation.js
>index 0643b98b304e433620e03e60fab64f447a216fbf..887bc50eeb97af4e900a04812665e2c2e8d29ddb 100644
>--- a/LayoutTests/storage/indexeddb/resources/prefetch-invalidation.js
>+++ b/LayoutTests/storage/indexeddb/resources/prefetch-invalidation.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Ensure IndexedDB's write operations invalidate cursor prefetch caches");
> 
> indexedDBTest(prepareDatabase, onOpenSuccess);
>diff --git a/LayoutTests/storage/indexeddb/resources/prefetch-race.js b/LayoutTests/storage/indexeddb/resources/prefetch-race.js
>index 60086e68cba7ce36ae5b32064968a16960a42421..c8dfb06a4141529388946cd364a0fc664252eda2 100644
>--- a/LayoutTests/storage/indexeddb/resources/prefetch-race.js
>+++ b/LayoutTests/storage/indexeddb/resources/prefetch-race.js
>@@ -3,6 +3,9 @@ if (this.importScripts) {
>     importScripts('shared.js');
> }
> 
>+if (testRunner)
>+    testRunner.clearAllDatabases();
>+
> description("Ensure IndexedDB's cursor prefetch cache requests are invalidated");
> 
> indexedDBTest(prepareDatabase, onOpenSuccess);
>diff --git a/LayoutTests/storage/indexeddb/resources/primary-key-unique-to-objectstore.js b/LayoutTests/storage/indexeddb/resources/primary-key-unique-to-objectstore.js
>index 26999a2ab3ae0c4d388e6e38e820715d4cd9b683..58ddb213ac409feb6779fbc5a9c1a4683545699c 100644
>--- a/LayoutTests/storage/indexeddb/resources/primary-key-unique-to-objectstore.js
>+++ b/LayoutTests/storage/indexeddb/resources/primary-key-unique-to-objectstore.js
>@@ -4,6 +4,7 @@ if (this.importScripts) {
> }
> 
> if (testRunner) {
>+    testRunner.clearAllDatabases();
>     testRunner.dumpAsText();
>     testRunner.waitUntilDone();
> }
>diff --git a/LayoutTests/storage/indexeddb/resources/storage-limit.js b/LayoutTests/storage/indexeddb/resources/storage-limit.js
>index 0d57b6c693f7d073bda9c3cc12905b0c5867c224..6e07b762812c6eee04a8f000300010c449f1bd2c 100644
>--- a/LayoutTests/storage/indexeddb/resources/storage-limit.js
>+++ b/LayoutTests/storage/indexeddb/resources/storage-limit.js
>@@ -2,37 +2,90 @@ if (this.importScripts) {
>     importScripts('../../../resources/js-test.js');
>     importScripts('shared.js');
> }
>+description("This test makes sure that indexedDB has a quota and the quota can grow.");
> 
>-var quota = 1024 * 1024; // 1 MB
>-description("This test makes sure that storage of indexedDB does not grow unboundedly.");
>+const initialQuota = 0;
>+const newQuota1 = Math.round(0.6 * 1024 * 1024);
>+const newQuota2 = 5 * 1024 * 1024;
>+const arraySize = Math.round(0.3 * 1024 * 1024 + 1);
> 
>-if (window.testRunner)
>-    testRunner.setIDBPerOriginQuota(quota);
>+function test() {
>+    if (window.testRunner) {
>+        testRunner.clearAllDatabases();
>+        testRunner.setIDBPerOriginQuota(initialQuota);
>+        testRunner.databaseDefaultQuota  = newQuota1;
>+    }
> 
>-indexedDBTest(prepareDatabase, onOpenSuccess);
>+    evalAndLog("arr = new Uint8Array(" + arraySize + ")");
>+    cleanOpenDatabase("dbWithQuota", unexpectedSuccessCallback, onOpenError);
>+}
> 
>-function prepareDatabase(event)
>+function cleanOpenDatabase(name, successCallack, errorCallack)
> {
>-    preamble(event);
>-    evalAndLog("db = event.target.result");
>-    evalAndLog("store = db.createObjectStore('store')");
>+    var deleteRequest = indexedDB.deleteDatabase('" + name + "');
>+    deleteRequest.onerror = unexpectedErrorCallback;
>+    deleteRequest.onsuccess = () => {
>+        openDatabase(name, successCallack, errorCallack);
>+    }
> }
> 
>-function onOpenSuccess(event)
>+function openDatabase(name, successCallack, errorCallack) 
> {
>-    preamble(event);
>-    evalAndLog("db = event.target.result");
>-    evalAndLog("store = db.transaction('store', 'readwrite').objectStore('store')");
>-    evalAndLog("request = store.add(new Uint8Array(" + (quota + 1) + "), 0)");
>-    request.onerror = function(event) {
>-        shouldBeTrue("'error' in request");
>-        shouldBe("request.error.code", "DOMException.QUOTA_EXCEEDED_ERR");
>-        shouldBeEqualToString("request.error.name", "QuotaExceededError");
>-        finishJSTest();
>+    preamble();
>+    openRequest = evalAndLog("indexedDB.open('"+ name +"')");
>+    openRequest.onupgradeneeded = () => { 
>+        request = evalAndLog("openRequest.result.createObjectStore('testObjectStore')"); 
>+        request.onerror = unexpectedErrorCallback;
>     }
>+    openRequest.onsuccess = successCallack;
>+    openRequest.onerror = errorCallack;
>+}
>+
>+function onOpenError()
>+{
>+    shouldBeTrue("'error' in openRequest");
>+    shouldBe("openRequest.error.code", "DOMException.QUOTA_EXCEEDED_ERR");
>+    shouldBeEqualToString("openRequest.error.name", "QuotaExceededError");
> 
>-    request.onsuccess = function(event) {
>-        testFailed("Add operation should fail because storage limit is reached, but succeeded.");
>-        finishJSTest();
>+    openDatabase("dbWithQuota", onOpenSuccess, unexpectedErrorCallback);
>+}
>+
>+function onOpenSuccess() 
>+{
>+    db = evalAndLog("db = event.target.result");
>+    if (db.name == "dbWithQuota")
>+        addToDatabase(() => { }, unexpectedErrorCallback, () => {
>+            cleanOpenDatabase("dbWithoutQuota", onOpenSuccess, unexpectedErrorCallback);
>+        });
>+    else {
>+        if (window.testRunner) 
>+            testRunner.databaseDefaultQuota  = newQuota2;
>+        addToDatabase(unexpectedSuccessCallback, onAddError, () => { });
>     }
>-}
>\ No newline at end of file
>+}
>+
>+function addToDatabase(successCallack, errorCallack, completeCallack)
>+{
>+    evalAndLog("tx =  db.transaction('testObjectStore', 'readwrite')");
>+    evalAndLog("store = tx.objectStore('testObjectStore')");
>+    tx.oncomplete = completeCallack;
>+    request = evalAndLog("request = store.add(arr, 0)");
>+    request.onsuccess = successCallack;
>+    request.onerror = errorCallack;
>+}
>+
>+function onAddError()
>+{
>+    shouldBeTrue("'error' in request");
>+    shouldBe("request.error.code", "DOMException.QUOTA_EXCEEDED_ERR");
>+    shouldBeEqualToString("request.error.name", "QuotaExceededError");
>+
>+    addToDatabase(finish, unexpectedErrorCallback, () => { });
>+}
>+
>+function finish()
>+{
>+    finishJSTest();
>+}
>+
>+test();
>diff --git a/LayoutTests/storage/indexeddb/storage-limit-expected.txt b/LayoutTests/storage/indexeddb/storage-limit-expected.txt
>index c314a44af6d700063c4ae0fbde47538b0aecb10d..91e1c315dfa65fc83ba560b49574db26346d2f03 100644
>--- a/LayoutTests/storage/indexeddb/storage-limit-expected.txt
>+++ b/LayoutTests/storage/indexeddb/storage-limit-expected.txt
>@@ -1,24 +1,37 @@
>-This test makes sure that storage of indexedDB does not grow unboundedly.
>+This test makes sure that indexedDB has a quota and the quota can grow.
> 
> On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
> 
> 
>-indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
>+arr = new Uint8Array(314574)
> 
>-indexedDB.deleteDatabase(dbname)
>-indexedDB.open(dbname)
>+openDatabase():
>+indexedDB.open('dbWithQuota')
>+PASS 'error' in openRequest is true
>+PASS openRequest.error.code is DOMException.QUOTA_EXCEEDED_ERR
>+PASS openRequest.error.name is "QuotaExceededError"
> 
>-prepareDatabase():
>+openDatabase():
>+indexedDB.open('dbWithQuota')
>+openRequest.result.createObjectStore('testObjectStore')
> db = event.target.result
>-store = db.createObjectStore('store')
>+tx =  db.transaction('testObjectStore', 'readwrite')
>+store = tx.objectStore('testObjectStore')
>+request = store.add(arr, 0)
> 
>-onOpenSuccess():
>+openDatabase():
>+indexedDB.open('dbWithoutQuota')
>+openRequest.result.createObjectStore('testObjectStore')
> db = event.target.result
>-store = db.transaction('store', 'readwrite').objectStore('store')
>-request = store.add(new Uint8Array(1048577), 0)
>+tx =  db.transaction('testObjectStore', 'readwrite')
>+store = tx.objectStore('testObjectStore')
>+request = store.add(arr, 0)
> PASS 'error' in request is true
> PASS request.error.code is DOMException.QUOTA_EXCEEDED_ERR
> PASS request.error.name is "QuotaExceededError"
>+tx =  db.transaction('testObjectStore', 'readwrite')
>+store = tx.objectStore('testObjectStore')
>+request = store.add(arr, 0)
> PASS successfullyParsed is true
> 
> TEST COMPLETE

Actions: View | Formatted Diff | Diff

Attachments on bug 192556: 356969 | 356991 | 356997 | 357001 | 357003 | 357088 | 357089 | 357092 | 357095 | 357096 | 357097 | 357107