Changeset 243270 in webkit


Ignore:
Timestamp:
Mar 20, 2019 6:24:52 PM (5 years ago)
Author:
youenn@apple.com
Message:

Include WAL and SHM file size in IDB database size computation
https://bugs.webkit.org/show_bug.cgi?id=195688

Reviewed by Brady Eidson.

Source/WebCore:

Count WAL and SHM files as part of IDB quota checks.
This makes some IDB tests go over the testing quota which then
triggers some IDB tasks to happen sooner than other write IDB tasks.
The IDB implementation requires these tasks to remain ordered.
In case a write task is pending quota check, queue all tasks,
write or read, to keep the order.

This patch specials case aborting a transaction.
In case it is called as part of clearing a database,
the task should not be queued and all pending tasks are errored.
When transaction is aborted by the web page, queue the task.

When we can make a decision to run tasks with size 0,
do not check quota. This ensures that read operations
succeed even if we are above quota.

Covered by existing tests.

  • Modules/indexeddb/server/UniqueIDBDatabase.cpp:

(WebCore::IDBServer::UniqueIDBDatabase::waitForRequestSpaceCompletion):
(WebCore::IDBServer::UniqueIDBDatabase::deleteObjectStore):
(WebCore::IDBServer::UniqueIDBDatabase::clearObjectStore):
(WebCore::IDBServer::UniqueIDBDatabase::deleteIndex):
(WebCore::IDBServer::UniqueIDBDatabase::getRecord):
(WebCore::IDBServer::UniqueIDBDatabase::getAllRecords):
(WebCore::IDBServer::UniqueIDBDatabase::getCount):
(WebCore::IDBServer::UniqueIDBDatabase::deleteRecord):
(WebCore::IDBServer::UniqueIDBDatabase::openCursor):
(WebCore::IDBServer::UniqueIDBDatabase::iterateCursor):
(WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):

  • Modules/indexeddb/server/UniqueIDBDatabase.h:
  • Modules/webdatabase/DatabaseTracker.cpp:

(WebCore::DatabaseTracker::usage):

  • platform/sql/SQLiteFileSystem.cpp:

(WebCore::SQLiteFileSystem::getDatabaseFileSize):

  • storage/StorageQuotaManager.h:
  • storage/StorageQuotaManager.cpp:

(WebCore::StorageQuotaManager::requestSpace):

LayoutTests:

  • storage/websql/open-database-creation-callback.html:

Bump quota for this test since WAL files are not included in quota computation.

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r243269 r243270  
     12019-03-20  Youenn Fablet  <youenn@apple.com>
     2
     3        Include WAL and SHM file size in IDB database size computation
     4        https://bugs.webkit.org/show_bug.cgi?id=195688
     5
     6        Reviewed by Brady Eidson.
     7
     8        * storage/websql/open-database-creation-callback.html:
     9        Bump quota for this test since WAL files are not included in quota computation.
     10
    1112019-03-20  Devin Rousso  <drousso@apple.com>
    212
  • trunk/LayoutTests/storage/websql/open-database-creation-callback.html

    r120516 r243270  
    1717    if (window.testRunner) {
    1818        testRunner.clearAllDatabases();
    19         testRunner.setDatabaseQuota(32768);
     19        testRunner.setDatabaseQuota(327680);
    2020        testRunner.dumpDatabaseCallbacks();
    2121        testRunner.dumpAsText();
  • trunk/Source/WebCore/ChangeLog

    r243269 r243270  
     12019-03-20  Youenn Fablet  <youenn@apple.com>
     2
     3        Include WAL and SHM file size in IDB database size computation
     4        https://bugs.webkit.org/show_bug.cgi?id=195688
     5
     6        Reviewed by Brady Eidson.
     7
     8        Count WAL and SHM files as part of IDB quota checks.
     9        This makes some IDB tests go over the testing quota which then
     10        triggers some IDB tasks to happen sooner than other write IDB tasks.
     11        The IDB implementation requires these tasks to remain ordered.
     12        In case a write task is pending quota check, queue all tasks,
     13        write or read, to keep the order.
     14
     15        This patch specials case aborting a transaction.
     16        In case it is called as part of clearing a database,
     17        the task should not be queued and all pending tasks are errored.
     18        When transaction is aborted by the web page, queue the task.
     19
     20        When we can make a decision to run tasks with size 0,
     21        do not check quota. This ensures that read operations
     22        succeed even if we are above quota.
     23
     24        Covered by existing tests.
     25
     26        * Modules/indexeddb/server/UniqueIDBDatabase.cpp:
     27        (WebCore::IDBServer::UniqueIDBDatabase::waitForRequestSpaceCompletion):
     28        (WebCore::IDBServer::UniqueIDBDatabase::deleteObjectStore):
     29        (WebCore::IDBServer::UniqueIDBDatabase::clearObjectStore):
     30        (WebCore::IDBServer::UniqueIDBDatabase::deleteIndex):
     31        (WebCore::IDBServer::UniqueIDBDatabase::getRecord):
     32        (WebCore::IDBServer::UniqueIDBDatabase::getAllRecords):
     33        (WebCore::IDBServer::UniqueIDBDatabase::getCount):
     34        (WebCore::IDBServer::UniqueIDBDatabase::deleteRecord):
     35        (WebCore::IDBServer::UniqueIDBDatabase::openCursor):
     36        (WebCore::IDBServer::UniqueIDBDatabase::iterateCursor):
     37        (WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):
     38        * Modules/indexeddb/server/UniqueIDBDatabase.h:
     39        * Modules/webdatabase/DatabaseTracker.cpp:
     40        (WebCore::DatabaseTracker::usage):
     41        * platform/sql/SQLiteFileSystem.cpp:
     42        (WebCore::SQLiteFileSystem::getDatabaseFileSize):
     43        * storage/StorageQuotaManager.h:
     44        * storage/StorageQuotaManager.cpp:
     45        (WebCore::StorageQuotaManager::requestSpace):
     46
    1472019-03-20  Devin Rousso  <drousso@apple.com>
    248
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp

    r243157 r243270  
    200200}
    201201
     202void UniqueIDBDatabase::waitForRequestSpaceCompletion(CompletionHandler<void(Optional<IDBError>&&)>&& callback)
     203{
     204    requestSpace(0, "", WTFMove(callback));
     205}
     206
    202207void UniqueIDBDatabase::performCurrentOpenOperation()
    203208{
     
    780785    requestSpace(taskSize, "createObjectStore", [this, taskSize, transaction = makeRef(transaction), info, callback = WTFMove(callback)](auto error) mutable {
    781786        if (error) {
    782             callback(WTFMove(error.value()));
     787            callback(WTFMove(*error));
    783788            return;
    784789        }
     
    824829    LOG(IndexedDB, "(main) UniqueIDBDatabase::deleteObjectStore");
    825830
     831    waitForRequestSpaceCompletion([this, transaction = makeRef(transaction), objectStoreName, callback = WTFMove(callback)](auto error) mutable {
     832        if (error) {
     833            callback(WTFMove(*error));
     834            return;
     835        }
     836        this->deleteObjectStoreAfterQuotaCheck(transaction, objectStoreName, WTFMove(callback));
     837    });
     838}
     839
     840void UniqueIDBDatabase::deleteObjectStoreAfterQuotaCheck(UniqueIDBDatabaseTransaction& transaction, const String& objectStoreName, ErrorCallback callback)
     841{
    826842    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    827843    if (!callbackID)
     
    868884    requestSpace(taskSize, "renameObjectStore", [this, taskSize, transaction = makeRef(transaction), objectStoreIdentifier, newName, callback = WTFMove(callback)](auto error) mutable {
    869885        if (error) {
    870             callback(WTFMove(error.value()));
     886            callback(WTFMove(*error));
    871887            return;
    872888        }
     
    918934    LOG(IndexedDB, "(main) UniqueIDBDatabase::clearObjectStore");
    919935
     936    waitForRequestSpaceCompletion([this, transaction = makeRef(transaction), objectStoreIdentifier, callback = WTFMove(callback)](auto error) mutable {
     937        if (error) {
     938            callback(WTFMove(*error));
     939            return;
     940        }
     941        this->clearObjectStoreAfetQuotaCheck(transaction, objectStoreIdentifier, WTFMove(callback));
     942    });
     943}
     944
     945void UniqueIDBDatabase::clearObjectStoreAfetQuotaCheck(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, ErrorCallback callback)
     946{
    920947    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    921948    if (!callbackID)
     
    952979    requestSpace(taskSize, "createIndex", [this, taskSize, transaction = makeRef(transaction), info, callback = WTFMove(callback)](auto error) mutable {
    953980        if (error) {
    954             callback(WTFMove(error.value()));
     981            callback(WTFMove(*error));
    955982            return;
    956983        }
     
    9981025    LOG(IndexedDB, "(main) UniqueIDBDatabase::deleteIndex");
    9991026
     1027    waitForRequestSpaceCompletion([this, transaction = makeRef(transaction), objectStoreIdentifier, indexName, callback = WTFMove(callback)](auto error) mutable {
     1028        if (error) {
     1029            callback(WTFMove(*error));
     1030            return;
     1031        }
     1032        this->deleteIndexAfterQuotaCheck(transaction, objectStoreIdentifier, indexName, WTFMove(callback));
     1033    });
     1034}
     1035
     1036void UniqueIDBDatabase::deleteIndexAfterQuotaCheck(UniqueIDBDatabaseTransaction& transaction, uint64_t objectStoreIdentifier, const String& indexName, ErrorCallback callback)
     1037{
    10001038    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    10011039    if (!callbackID)
     
    10511089    requestSpace(taskSize, "renameIndex", [this, taskSize, transaction = makeRef(transaction), objectStoreIdentifier, indexIdentifier, newName, callback = WTFMove(callback)](auto error) mutable {
    10521090        if (error) {
    1053             callback(WTFMove(error.value()));
     1091            callback(WTFMove(*error));
    10541092            return;
    10551093        }
     
    11171155    requestSpace(taskSize, "putOrAdd", [this, taskSize, requestData, keyData, value, callback = WTFMove(callback), overwriteMode](auto error) mutable {
    11181156        if (error) {
    1119             callback(WTFMove(error.value()), { });
     1157            callback(WTFMove(*error), { });
    11201158            return;
    11211159        }
     
    12661304    LOG(IndexedDB, "(main) UniqueIDBDatabase::getRecord");
    12671305
     1306    waitForRequestSpaceCompletion([this, requestData, getRecordData, callback = WTFMove(callback)](auto error) mutable {
     1307        if (error) {
     1308            callback(WTFMove(*error), { });
     1309            return;
     1310        }
     1311        this->getRecordAfterQuotaCheck(requestData, getRecordData, WTFMove(callback));
     1312    });
     1313}
     1314
     1315void UniqueIDBDatabase::getRecordAfterQuotaCheck(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData, GetResultCallback callback)
     1316{
    12681317    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    12691318    if (!callbackID)
     
    12811330    LOG(IndexedDB, "(main) UniqueIDBDatabase::getAllRecords");
    12821331
     1332    waitForRequestSpaceCompletion([this, requestData, getAllRecordsData, callback = WTFMove(callback)](auto error) mutable {
     1333        if (error) {
     1334            callback(WTFMove(*error), { });
     1335            return;
     1336        }
     1337        this->getAllRecordsAfterQuotaCheck(requestData, getAllRecordsData, WTFMove(callback));
     1338    });
     1339}
     1340
     1341void UniqueIDBDatabase::getAllRecordsAfterQuotaCheck(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData, GetAllResultsCallback callback)
     1342{
    12831343    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    12841344    if (!callbackID)
     
    13481408    LOG(IndexedDB, "(main) UniqueIDBDatabase::getCount");
    13491409
     1410    waitForRequestSpaceCompletion([this, requestData, range, callback = WTFMove(callback)](auto error) mutable {
     1411        if (error) {
     1412            callback(WTFMove(*error), { });
     1413            return;
     1414        }
     1415        this->getCountAfterQuotaCheck(requestData, range, WTFMove(callback));
     1416    });
     1417}
     1418
     1419void UniqueIDBDatabase::getCountAfterQuotaCheck(const IDBRequestData& requestData, const IDBKeyRangeData& range, CountCallback callback)
     1420{
    13501421    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    13511422    if (!callbackID)
     
    13811452    LOG(IndexedDB, "(main) UniqueIDBDatabase::deleteRecord");
    13821453
     1454    waitForRequestSpaceCompletion([this, requestData, keyRangeData, callback = WTFMove(callback)](auto error) mutable {
     1455        if (error) {
     1456            callback(WTFMove(*error));
     1457            return;
     1458        }
     1459        this->deleteRecordAfterQuotaCheck(requestData, keyRangeData, WTFMove(callback));
     1460    });
     1461}
     1462
     1463void UniqueIDBDatabase::deleteRecordAfterQuotaCheck(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData, ErrorCallback callback)
     1464{
    13831465    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    13841466    if (!callbackID)
     
    14101492    LOG(IndexedDB, "(main) UniqueIDBDatabase::openCursor");
    14111493
     1494    waitForRequestSpaceCompletion([this, requestData, info, callback = WTFMove(callback)](auto error) mutable {
     1495        if (error) {
     1496            callback(WTFMove(*error), { });
     1497            return;
     1498        }
     1499        this->openCursorAfterQuotaCheck(requestData, info, WTFMove(callback));
     1500    });
     1501}
     1502
     1503void UniqueIDBDatabase::openCursorAfterQuotaCheck(const IDBRequestData& requestData, const IDBCursorInfo& info, GetResultCallback callback)
     1504{
    14121505    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    14131506    if (!callbackID)
     
    14401533    LOG(IndexedDB, "(main) UniqueIDBDatabase::iterateCursor");
    14411534
     1535    waitForRequestSpaceCompletion([this, requestData, data, callback = WTFMove(callback)](auto error) mutable {
     1536        if (error) {
     1537            callback(WTFMove(*error), { });
     1538            return;
     1539        }
     1540        this->iterateCursorAfterQuotaCheck(requestData, data, WTFMove(callback));
     1541    });
     1542}
     1543
     1544void UniqueIDBDatabase::iterateCursorAfterQuotaCheck(const IDBRequestData& requestData, const IDBIterateCursorData& data, GetResultCallback callback)
     1545{
    14421546    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    14431547    if (!callbackID)
     
    15021606    ASSERT(transaction.databaseConnection().database() == this);
    15031607
     1608    waitForRequestSpaceCompletion([this, transaction = makeRef(transaction), callback = WTFMove(callback)](auto error) mutable {
     1609        if (error) {
     1610            callback(WTFMove(*error));
     1611            return;
     1612        }
     1613        this->commitTransactionAfterQuotaCheck(transaction, WTFMove(callback));
     1614    });
     1615}
     1616
     1617void UniqueIDBDatabase::commitTransactionAfterQuotaCheck(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)
     1618{
    15041619    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
    15051620    if (!callbackID)
     
    15391654}
    15401655
    1541 void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, ErrorCallback callback)
     1656void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transaction, WaitForPendingTasks waitForPendingTasks, ErrorCallback callback)
    15421657{
    15431658    ASSERT(isMainThread());
     
    15451660
    15461661    ASSERT(transaction.databaseConnection().database() == this);
     1662
     1663    if (waitForPendingTasks == WaitForPendingTasks::Yes) {
     1664        waitForRequestSpaceCompletion([this, transaction = makeRef(transaction), callback = WTFMove(callback)](auto&& error) mutable {
     1665            if (error) {
     1666                callback(WTFMove(*error));
     1667                return;
     1668            }
     1669            this->abortTransaction(transaction, WaitForPendingTasks::No, WTFMove(callback));
     1670        });
     1671        return;
     1672    }
    15471673
    15481674    uint64_t callbackID = storeCallbackOrFireError(WTFMove(callback));
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h

    r242911 r243270  
    102102    void iterateCursor(const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback);
    103103    void commitTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
    104     void abortTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
     104
     105    enum class WaitForPendingTasks { No, Yes };
     106    void abortTransaction(UniqueIDBDatabaseTransaction&, WaitForPendingTasks, ErrorCallback);
     107
    105108    void didFinishHandlingVersionChange(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& transactionIdentifier);
    106109    void transactionDestroyed(UniqueIDBDatabaseTransaction&);
     
    153156    void renameIndexAfterQuotaCheck(uint64_t taskSize, UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName, ErrorCallback);
    154157    void putOrAddAfterQuotaCheck(uint64_t taskSize, const IDBRequestData&, const IDBKeyData&, const IDBValue&, IndexedDB::ObjectStoreOverwriteMode, KeyDataCallback);
     158    void deleteRecordAfterQuotaCheck(const IDBRequestData&, const IDBKeyRangeData&, ErrorCallback);
     159
     160    void deleteObjectStoreAfterQuotaCheck(UniqueIDBDatabaseTransaction&, const String& objectStoreName, ErrorCallback);
     161    void clearObjectStoreAfetQuotaCheck(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, ErrorCallback);
     162    void deleteIndexAfterQuotaCheck(UniqueIDBDatabaseTransaction&, uint64_t objectStoreIdentifier, const String&, ErrorCallback);
     163    void getRecordAfterQuotaCheck(const IDBRequestData&, const IDBGetRecordData&, GetResultCallback);
     164    void getAllRecordsAfterQuotaCheck(const IDBRequestData&, const IDBGetAllRecordsData&, GetAllResultsCallback);
     165    void getCountAfterQuotaCheck(const IDBRequestData&, const IDBKeyRangeData&, CountCallback);
     166    void openCursorAfterQuotaCheck(const IDBRequestData&, const IDBCursorInfo&, GetResultCallback);
     167    void iterateCursorAfterQuotaCheck(const IDBRequestData&, const IDBIterateCursorData&, GetResultCallback);
     168    void commitTransactionAfterQuotaCheck(UniqueIDBDatabaseTransaction&, ErrorCallback);
    155169
    156170    // Database thread operations
     
    241255
    242256    void requestSpace(uint64_t taskSize, const char* errorMessage, CompletionHandler<void(Optional<IDBError>&&)>&&);
     257    void waitForRequestSpaceCompletion(CompletionHandler<void(Optional<IDBError>&&)>&&);
    243258    void updateSpaceUsedIfNeeded(uint64_t callbackIdentifier);
    244259
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp

    r240039 r243270  
    7676        return;
    7777   
    78     m_database->abortTransaction(transaction, [this, protectedThis, transactionIdentifier](const IDBError&) {
     78    m_database->abortTransaction(transaction, UniqueIDBDatabase::WaitForPendingTasks::No, [this, protectedThis, transactionIdentifier](const IDBError&) {
    7979        ASSERT(m_transactionMap.contains(transactionIdentifier));
    8080        m_transactionMap.remove(transactionIdentifier);
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp

    r239266 r243270  
    8282    ASSERT(database);
    8383
    84     database->abortTransaction(*this, [this, protectedThis](const IDBError& error) {
     84    database->abortTransaction(*this, UniqueIDBDatabase::WaitForPendingTasks::Yes, [this, protectedThis](const IDBError& error) {
    8585        LOG(IndexedDB, "UniqueIDBDatabaseTransaction::abort (callback)");
    8686        m_databaseConnection->didAbortTransaction(*this, error);
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTracker.cpp

    r243219 r243270  
    656656    String originPath = this->originPath(origin);
    657657    unsigned long long diskUsage = 0;
    658     for (auto& fileName : FileSystem::listDirectory(originPath, "*.db"_s)) {
    659         long long size;
    660         FileSystem::getFileSize(fileName, size);
    661         diskUsage += size;
    662     }
     658    for (auto& fileName : FileSystem::listDirectory(originPath, "*.db"_s))
     659        diskUsage += SQLiteFileSystem::getDatabaseFileSize(fileName);
    663660    return diskUsage;
    664661}
  • trunk/Source/WebCore/platform/sql/SQLiteFileSystem.cpp

    r243019 r243270  
    101101long long SQLiteFileSystem::getDatabaseFileSize(const String& fileName)
    102102{       
    103     long long size;
    104     return FileSystem::getFileSize(fileName, size) ? size : 0;
     103    long long fileSize = 0;
     104    long long totalSize = 0;
     105
     106    if (FileSystem::getFileSize(fileName, fileSize))
     107        totalSize += fileSize;
     108
     109    if (FileSystem::getFileSize(makeString(fileName, "-wal"_s), fileSize))
     110        totalSize += fileSize;
     111
     112    if (FileSystem::getFileSize(makeString(fileName, "-shm"_s), fileSize))
     113        totalSize += fileSize;
     114
     115    return totalSize;
    105116}
    106117
  • trunk/Source/WebCore/storage/StorageQuotaManager.cpp

    r242911 r243270  
    5959}
    6060
     61bool StorageQuotaManager::shouldAskForMoreSpace(uint64_t spaceIncrease) const
     62{
     63    if (!spaceIncrease)
     64        return false;
     65
     66    return spaceUsage() + spaceIncrease > m_quota;
     67}
     68
    6169void StorageQuotaManager::requestSpace(uint64_t spaceIncrease, RequestCallback&& callback)
    6270{
     
    6674    }
    6775
    68     auto spaceUsage = this->spaceUsage();
    69     if (spaceUsage + spaceIncrease > m_quota) {
     76    if (shouldAskForMoreSpace(spaceIncrease)) {
    7077        m_pendingRequests.append({ spaceIncrease, WTFMove(callback) });
    71         askForMoreSpace(spaceUsage, spaceIncrease);
     78        askForMoreSpace(spaceIncrease);
    7279        return;
    7380    }
     
    7582}
    7683
    77 void StorageQuotaManager::askForMoreSpace(uint64_t spaceUsage, uint64_t spaceIncrease)
     84void StorageQuotaManager::askForMoreSpace(uint64_t spaceIncrease)
    7885{
    79     ASSERT(spaceUsage + spaceIncrease > m_quota);
    80     m_spaceIncreaseRequester(m_quota, spaceUsage, spaceIncrease, [this, weakThis = makeWeakPtr(*this)](Optional<uint64_t> newQuota) {
     86    ASSERT(shouldAskForMoreSpace(spaceIncrease));
     87    m_spaceIncreaseRequester(m_quota, spaceUsage(), spaceIncrease, [this, weakThis = makeWeakPtr(*this)](Optional<uint64_t> newQuota) {
    8188        if (!weakThis)
    8289            return;
     
    94101
    95102    auto request = m_pendingRequests.takeFirst();
    96     auto decision = m_quota >= (spaceUsage() + request.spaceIncrease) ? Decision::Grant : Decision::Deny;
     103    auto decision = shouldAskForMoreSpace(request.spaceIncrease) ? Decision::Deny : Decision::Grant;
    97104    request.callback(decision);
    98105
     
    100107        auto& request = m_pendingRequests.first();
    101108
    102         auto spaceUsage = this->spaceUsage();
    103         if (m_quota < spaceUsage + request.spaceIncrease) {
     109        if (shouldAskForMoreSpace(request.spaceIncrease)) {
    104110            uint64_t spaceIncrease = 0;
    105111            for (auto& request : m_pendingRequests)
    106112                spaceIncrease += request.spaceIncrease;
    107             askForMoreSpace(spaceUsage, spaceIncrease);
     113            askForMoreSpace(spaceIncrease);
    108114            return;
    109115        }
  • trunk/Source/WebCore/storage/StorageQuotaManager.h

    r243247 r243270  
    6565private:
    6666    uint64_t spaceUsage() const;
    67     void askForMoreSpace(uint64_t spaceUsage, uint64_t spaceIncrease);
     67    bool shouldAskForMoreSpace(uint64_t spaceIncrease) const;
     68    void askForMoreSpace(uint64_t spaceIncrease);
    6869    void processPendingRequests(Optional<uint64_t>);
    6970
Note: See TracChangeset for help on using the changeset viewer.