Changeset 57286 in webkit


Ignore:
Timestamp:
Apr 8, 2010 11:40:00 AM (14 years ago)
Author:
dumi@chromium.org
Message:

Refactor DatabaseTracker, part 1: Remove the dependency on
OriginQuotaManager from DatabaseTracker.h.

Reviewed by Dimitri Glazkov.

​https://bugs.webkit.org/show_bug.cgi?id=31482

  • storage/DatabaseTracker.cpp:

(originQuotaManager):
(WebCore::DatabaseTracker::DatabaseTracker):
(WebCore::DatabaseTracker::canEstablishDatabase):
(WebCore::DatabaseTracker::hasEntryForOrigin):
(WebCore::DatabaseTracker::getMaxSizeForDatabase):
(WebCore::DatabaseTracker::databaseChanged):
(WebCore::DatabaseTracker::fullPathForDatabaseNoLock):
(WebCore::DatabaseTracker::fullPathForDatabase):
(WebCore::DatabaseTracker::populateOrigins):
(WebCore::DatabaseTracker::origins):
(WebCore::DatabaseTracker::databaseNamesForOrigin):
(WebCore::DatabaseTracker::removeOpenDatabase):
(WebCore::DatabaseTracker::usageForOriginNoLock):
(WebCore::DatabaseTracker::usageForOrigin):
(WebCore::DatabaseTracker::quotaForOrigin):
(WebCore::DatabaseTracker::setQuota):
(WebCore::DatabaseTracker::deleteOrigin):
(WebCore::DatabaseTracker::deleteDatabase):
(WebCore::DatabaseTracker::deleteDatabaseFile):

  • storage/DatabaseTracker.h:
  • storage/SQLTransactionClient.cpp:

(WebCore::SQLTransactionClient::didExecuteStatement):

Location:
trunk/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r57283 r57286  
     12010-03-30  Dumitru Daniliuc  <dumi@chromium.org>
     2
     3        Reviewed by Dimitri Glazkov.
     4
     5        Refactor DatabaseTracker, part 1: Remove the dependency on
     6        OriginQuotaManager from DatabaseTracker.h.
     7
     8        https://bugs.webkit.org/show_bug.cgi?id=31482
     9
     10        * storage/DatabaseTracker.cpp:
     11        (originQuotaManager):
     12        (WebCore::DatabaseTracker::DatabaseTracker):
     13        (WebCore::DatabaseTracker::canEstablishDatabase):
     14        (WebCore::DatabaseTracker::hasEntryForOrigin):
     15        (WebCore::DatabaseTracker::getMaxSizeForDatabase):
     16        (WebCore::DatabaseTracker::databaseChanged):
     17        (WebCore::DatabaseTracker::fullPathForDatabaseNoLock):
     18        (WebCore::DatabaseTracker::fullPathForDatabase):
     19        (WebCore::DatabaseTracker::populateOrigins):
     20        (WebCore::DatabaseTracker::origins):
     21        (WebCore::DatabaseTracker::databaseNamesForOrigin):
     22        (WebCore::DatabaseTracker::removeOpenDatabase):
     23        (WebCore::DatabaseTracker::usageForOriginNoLock):
     24        (WebCore::DatabaseTracker::usageForOrigin):
     25        (WebCore::DatabaseTracker::quotaForOrigin):
     26        (WebCore::DatabaseTracker::setQuota):
     27        (WebCore::DatabaseTracker::deleteOrigin):
     28        (WebCore::DatabaseTracker::deleteDatabase):
     29        (WebCore::DatabaseTracker::deleteDatabaseFile):
     30        * storage/DatabaseTracker.h:
     31        * storage/SQLTransactionClient.cpp:
     32        (WebCore::SQLTransactionClient::didExecuteStatement):
     33
    1342010-04-08  Kwang Yul Seo  <skyul@company100.net>
    235

  • trunk/WebCore/storage/DatabaseTracker.cpp

    r57128 r57286  
    5050using namespace std;
    5151
     52static WebCore::OriginQuotaManager& originQuotaManager()
     53{
     54    DEFINE_STATIC_LOCAL(WebCore::OriginQuotaManager, quotaManager, ());
     55    return quotaManager;
     56}
     57
    5258namespace WebCore {
    53 
    54 OriginQuotaManager& DatabaseTracker::originQuotaManagerNoLock()
    55 {
    56     ASSERT(m_quotaManager);
    57     return *m_quotaManager;
    58 }
    59 
    60 OriginQuotaManager& DatabaseTracker::originQuotaManager()
    61 {
    62     MutexLocker lockDatabase(m_databaseGuard);
    63     populateOrigins();
    64     return originQuotaManagerNoLock();
    65 }
    6659
    6760DatabaseTracker& DatabaseTracker::tracker()
    … …  
    7568{
    7669    SQLiteFileSystem::registerSQLiteVFS();
     70
     71    MutexLocker lockDatabase(m_databaseGuard);
     72    populateOrigins();
    7773}
    7874
    … …  
    133129    unsigned long long tempUsage;
    134130    {
    135         Locker<OriginQuotaManager> locker(originQuotaManager());
    136131        MutexLocker lockDatabase(m_databaseGuard);
     132        Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    137133
    138134        if (!canCreateDatabase(origin, name))
    … …  
    140136
    141137        recordCreatingDatabase(origin, name);
    142 
    143         populateOrigins();
    144138
    145139        // Since we're imminently opening a database within this context's origin, make sure this origin is being tracked by the QuotaTracker
    … …  
    193187{
    194188    MutexLocker lockDatabase(m_databaseGuard);
    195     populateOrigins();
    196189    return hasEntryForOriginNoLock(origin);
    197190}
    … …  
    219212    // The maximum size for a database is the full quota for its origin, minus the current usage within the origin,
    220213    // plus the current usage of the given database
    221     Locker<OriginQuotaManager> locker(originQuotaManager());
     214    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    222215    SecurityOrigin* origin = database->securityOrigin();
    223216    return quotaForOrigin(origin) - originQuotaManager().diskUsage(origin) + SQLiteFileSystem::getDatabaseFileSize(database->fileName());
    224217}
    225218
     219void DatabaseTracker::databaseChanged(Database* database)
     220{
     221    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
     222    originQuotaManager().markDatabase(database);
     223}
     224
    226225String DatabaseTracker::originPath(SecurityOrigin* origin) const
    227226{
    … …  
    232231{
    233232    ASSERT(!m_databaseGuard.tryLock());
    234     ASSERT(!originQuotaManagerNoLock().tryLock());
     233    ASSERT(!originQuotaManager().tryLock());
    235234
    236235    for (HashSet<ProposedDatabase*>::iterator iter = m_proposedDatabases.begin(); iter != m_proposedDatabases.end(); ++iter)
    … …  
    276275    // to the quota manager now
    277276    String fullFilePath = SQLiteFileSystem::appendDatabaseFileNameToPath(originPath, fileName);
    278     if (originQuotaManagerNoLock().tracksOrigin(origin))
    279         originQuotaManagerNoLock().addDatabase(origin, name, fullFilePath);
     277    if (originQuotaManager().tracksOrigin(origin))
     278        originQuotaManager().addDatabase(origin, name, fullFilePath);
    280279
    281280    return fullFilePath;
    … …  
    284283String DatabaseTracker::fullPathForDatabase(SecurityOrigin* origin, const String& name, bool createIfNotExists)
    285284{
    286     Locker<OriginQuotaManager> locker(originQuotaManager());
    287     MutexLocker lockDatabase(m_databaseGuard);
    288     populateOrigins();
     285    MutexLocker lockDatabase(m_databaseGuard);
     286    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    289287
    290288    return fullPathForDatabaseNoLock(origin, name, createIfNotExists).threadsafeCopy();
    … …  
    298296
    299297    m_quotaMap.set(new QuotaMap);
    300     if (!m_quotaManager)
    301         m_quotaManager.set(new OriginQuotaManager);
    302298
    303299    openTrackerDatabase(false);
    … …  
    325321{
    326322    MutexLocker lockDatabase(m_databaseGuard);
    327     populateOrigins();
    328323    ASSERT(m_quotaMap);
    329324    copyKeysToVector(*m_quotaMap, result);
    … …  
    358353bool DatabaseTracker::databaseNamesForOrigin(SecurityOrigin* origin, Vector<String>& resultVector)
    359354{
    360     MutexLocker lockDatabase(m_databaseGuard);
    361355    Vector<String> temp;
    362     if (!databaseNamesForOriginNoLock(origin, temp))
    363         return false;
     356    {
     357        MutexLocker lockDatabase(m_databaseGuard);
     358        if (!databaseNamesForOriginNoLock(origin, temp))
     359          return false;
     360    }
    364361
    365362    for (Vector<String>::iterator iter = temp.begin(); iter != temp.end(); ++iter)
    … …  
    474471        return;
    475472
    476     MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
    477 
    478     if (!m_openDatabaseMap)
    479         m_openDatabaseMap.set(new DatabaseOriginMap);
    480 
    481     String name(database->stringIdentifier());
    482     DatabaseNameMap* nameMap = m_openDatabaseMap->get(database->securityOrigin());
    483     if (!nameMap) {
    484         nameMap = new DatabaseNameMap;
    485         m_openDatabaseMap->set(database->securityOrigin()->threadsafeCopy(), nameMap);
    486     }
    487 
    488     DatabaseSet* databaseSet = nameMap->get(name);
    489     if (!databaseSet) {
    490         databaseSet = new DatabaseSet;
    491         nameMap->set(name.threadsafeCopy(), databaseSet);
    492     }
    493 
    494     databaseSet->add(database);
    495 
    496     LOG(StorageAPI, "Added open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);
     473    {
     474        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
     475
     476        if (!m_openDatabaseMap)
     477            m_openDatabaseMap.set(new DatabaseOriginMap);
     478
     479        String name(database->stringIdentifier());
     480        DatabaseNameMap* nameMap = m_openDatabaseMap->get(database->securityOrigin());
     481        if (!nameMap) {
     482            nameMap = new DatabaseNameMap;
     483            m_openDatabaseMap->set(database->securityOrigin()->threadsafeCopy(), nameMap);
     484        }
     485
     486        DatabaseSet* databaseSet = nameMap->get(name);
     487        if (!databaseSet) {
     488            databaseSet = new DatabaseSet;
     489            nameMap->set(name.threadsafeCopy(), databaseSet);
     490        }
     491
     492        databaseSet->add(database);
     493
     494        LOG(StorageAPI, "Added open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);
     495    }
    497496
    498497    MutexLocker lockDatabase(m_databaseGuard);
    … …  
    505504        return;
    506505
     506    {
     507        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
     508
     509        if (!m_openDatabaseMap) {
     510            ASSERT_NOT_REACHED();
     511            return;
     512        }
     513
     514        String name(database->stringIdentifier());
     515        DatabaseNameMap* nameMap = m_openDatabaseMap->get(database->securityOrigin());
     516        if (!nameMap) {
     517            ASSERT_NOT_REACHED();
     518            return;
     519        }
     520
     521        DatabaseSet* databaseSet = nameMap->get(name);
     522        if (!databaseSet) {
     523            ASSERT_NOT_REACHED();
     524            return;
     525        }
     526
     527        databaseSet->remove(database);
     528
     529        LOG(StorageAPI, "Removed open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);
     530
     531        if (!databaseSet->isEmpty())
     532            return;
     533
     534        nameMap->remove(name);
     535        delete databaseSet;
     536
     537        if (!nameMap->isEmpty())
     538            return;
     539
     540        m_openDatabaseMap->remove(database->securityOrigin());
     541        delete nameMap;
     542    }
     543
    507544    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    508     MutexLocker lockDatabase(m_databaseGuard);
    509     MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
    510 
    511     if (!m_openDatabaseMap) {
    512         ASSERT_NOT_REACHED();
    513         return;
    514     }
    515 
    516     String name(database->stringIdentifier());
    517     DatabaseNameMap* nameMap = m_openDatabaseMap->get(database->securityOrigin());
    518     if (!nameMap) {
    519         ASSERT_NOT_REACHED();
    520         return;
    521     }
    522 
    523     DatabaseSet* databaseSet = nameMap->get(name);
    524     if (!databaseSet) {
    525         ASSERT_NOT_REACHED();
    526         return;
    527     }
    528 
    529     databaseSet->remove(database);
    530 
    531     LOG(StorageAPI, "Removed open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);
    532 
    533     if (!databaseSet->isEmpty())
    534         return;
    535 
    536     nameMap->remove(name);
    537     delete databaseSet;
    538 
    539     if (!nameMap->isEmpty())
    540         return;
    541 
    542     m_openDatabaseMap->remove(database->securityOrigin());
    543     delete nameMap;
    544     originQuotaManagerNoLock().removeOrigin(database->securityOrigin());
     545    originQuotaManager().removeOrigin(database->securityOrigin());
    545546}
    546547
    … …  
    565566unsigned long long DatabaseTracker::usageForOriginNoLock(SecurityOrigin* origin)
    566567{
    567     ASSERT(!originQuotaManagerNoLock().tryLock());
     568    ASSERT(!originQuotaManager().tryLock());
    568569
    569570    // Use the OriginQuotaManager mechanism to calculate the usage
    570     if (originQuotaManagerNoLock().tracksOrigin(origin))
    571         return originQuotaManagerNoLock().diskUsage(origin);
     571    if (originQuotaManager().tracksOrigin(origin))
     572        return originQuotaManager().diskUsage(origin);
    572573
    573574    // If the OriginQuotaManager doesn't track this origin already, prime it to do so
    574     originQuotaManagerNoLock().trackOrigin(origin);
     575    originQuotaManager().trackOrigin(origin);
    575576
    576577    Vector<String> names;
    … …  
    578579
    579580    for (unsigned i = 0; i < names.size(); ++i)
    580         originQuotaManagerNoLock().addDatabase(origin, names[i], fullPathForDatabaseNoLock(origin, names[i], false));
    581 
    582     if (!originQuotaManagerNoLock().tracksOrigin(origin))
     581        originQuotaManager().addDatabase(origin, names[i], fullPathForDatabaseNoLock(origin, names[i], false));
     582
     583    if (!originQuotaManager().tracksOrigin(origin))
    583584        return 0;
    584     return originQuotaManagerNoLock().diskUsage(origin);
     585    return originQuotaManager().diskUsage(origin);
    585586}
    586587
    587588unsigned long long DatabaseTracker::usageForOrigin(SecurityOrigin* origin)
    588589{
    589     Locker<OriginQuotaManager> locker(originQuotaManager());
    590 
     590    MutexLocker lockDatabase(m_databaseGuard);
     591    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    591592    return usageForOriginNoLock(origin);
    592593}
    … …  
    602603{
    603604    MutexLocker lockDatabase(m_databaseGuard);
    604     populateOrigins();
    605605    return quotaForOriginNoLock(origin);
    606606}
    … …  
    610610    MutexLocker lockDatabase(m_databaseGuard);
    611611
    612     populateOrigins();
    613612    if (quotaForOriginNoLock(origin) == quota)
    614613        return;
    … …  
    722721
    723722    {
    724         // To satisfy the lock hierarchy, we have to lock the originQuotaManager before m_databaseGuard if there's any chance we'll to lock both.
    725         Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    726723        MutexLocker lockDatabase(m_databaseGuard);
     724        doneDeletingOrigin(origin);
     725
    727726        SQLiteStatement statement(m_database, "DELETE FROM Databases WHERE origin=?");
    728 
    729         doneDeletingOrigin(origin);
    730 
    731727        if (statement.prepare() != SQLResultOk) {
    732728            LOG_ERROR("Unable to prepare deletion of databases from origin %s from tracker", origin->databaseIdentifier().ascii().data());
    … …  
    759755        m_quotaMap->remove(origin);
    760756
    761         originQuotaManagerNoLock().removeOrigin(origin);
     757        {
     758            Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
     759            originQuotaManager().removeOrigin(origin);
     760        }
    762761
    763762        // If we removed the last origin, do some additional deletion.
    … …  
    914913    }
    915914
    916     // To satisfy the lock hierarchy, we have to lock the originQuotaManager before m_databaseGuard if there's any chance we'll to lock both.
    917     Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    918915    MutexLocker lockDatabase(m_databaseGuard);
    919916
    … …  
    934931    }
    935932
    936     originQuotaManagerNoLock().removeDatabase(origin, name);
     933    {
     934        Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
     935        originQuotaManager().removeDatabase(origin, name);
     936    }
    937937
    938938    if (m_client) {
    … …  
    955955#ifndef NDEBUG
    956956    {
    957     MutexLocker lockDatabase(m_databaseGuard);
    958     ASSERT(deletingDatabase(origin, name) || deletingOrigin(origin));
     957        MutexLocker lockDatabase(m_databaseGuard);
     958        ASSERT(deletingDatabase(origin, name) || deletingOrigin(origin));
    959959    }
    960960#endif

  • trunk/WebCore/storage/DatabaseTracker.h

    r56954 r57286  
    5353#if !PLATFORM(CHROMIUM)
    5454class DatabaseTrackerClient;
    55 class OriginQuotaManager;
    5655
    5756struct SecurityOriginTraits;
    … …  
    6362    // This singleton will potentially be used from multiple worker threads and the page's context thread simultaneously.  To keep this safe, it's
    6463    // currently using 4 locks.  In order to avoid deadlock when taking multiple locks, you must take them in the correct order:
    65     // originQuotaManager() before m_databaseGuard or m_openDatabaseMapGuard
    66     // m_databaseGuard before m_openDatabaseMapGuard
     64    // m_databaseGuard before originQuotaManager() if both locks are needed.
     65    // m_openDatabaseMapGuard is currently independent of the other locks.
    6766    // notificationMutex() is currently independent of the other locks.
    6867
    … …  
    7675
    7776    unsigned long long getMaxSizeForDatabase(const Database*);
     77    void databaseChanged(Database*);
    7878
    7979private:
    … …  
    111111    void scheduleNotifyDatabaseChanged(SecurityOrigin*, const String& name);
    112112
    113     OriginQuotaManager& originQuotaManager();
    114 
    115 
    116113    bool hasEntryForOrigin(SecurityOrigin*);
    117114
    118115private:
    119     OriginQuotaManager& originQuotaManagerNoLock();
    120116    bool hasEntryForOriginNoLock(SecurityOrigin* origin);
    121117    String fullPathForDatabaseNoLock(SecurityOrigin*, const String& name, bool createIfDoesNotExist);
    … …  
    142138    typedef HashMap<RefPtr<SecurityOrigin>, unsigned long long, SecurityOriginHash> QuotaMap;
    143139    mutable OwnPtr<QuotaMap> m_quotaMap;
    144 
    145     OwnPtr<OriginQuotaManager> m_quotaManager;
    146140
    147141    String m_databaseDirectoryPath;

  • trunk/WebCore/storage/SQLTransactionClient.cpp

    r53595 r57286  
    4040#include "DatabaseTracker.h"
    4141#include "Document.h"
    42 #include "OriginQuotaManager.h"
    4342#include "Page.h"
    4443#include "SQLTransaction.h"
    … …  
    5756{
    5857    ASSERT(currentThread() == transaction->database()->scriptExecutionContext()->databaseThread()->getThreadID());
    59     OriginQuotaManager& manager(DatabaseTracker::tracker().originQuotaManager());
    60     Locker<OriginQuotaManager> locker(manager);
    61     manager.markDatabase(transaction->database());
     58    DatabaseTracker::tracker().databaseChanged(transaction->database());
    6259}
    6360
Note: See TracChangeset for help on using the changeset viewer.