Changeset 147796 in webkit


Ignore:
Timestamp:
Apr 5, 2013 1:52:10 PM (11 years ago)
Author:
benjamin@webkit.org
Message:

Clean the chromium bits of WebCore's WebDatabase
​https://bugs.webkit.org/show_bug.cgi?id=114010

Reviewed by Ryosuke Niwa.

  • Modules/webdatabase/AbstractDatabaseServer.h:
  • Modules/webdatabase/ChangeVersionWrapper.cpp:

(WebCore::ChangeVersionWrapper::performPreflight):
(WebCore::ChangeVersionWrapper::performPostflight):

  • Modules/webdatabase/Database.cpp:
  • Modules/webdatabase/Database.h:

(Database):

  • Modules/webdatabase/DatabaseBackend.cpp:

(WebCore::DatabaseBackend::openAndVerifyVersion):

  • Modules/webdatabase/DatabaseBackendBase.cpp:

(WebCore::DoneCreatingDatabaseOnExitCaller::~DoneCreatingDatabaseOnExitCaller):
(WebCore::DatabaseBackendBase::performOpenAndVerify):
(WebCore::DatabaseBackendBase::getActualVersionForTransaction):
(WebCore::DatabaseBackendBase::incrementalVacuumIfNeeded):

  • Modules/webdatabase/DatabaseBackendBase.h:

(DatabaseBackendBase):

  • Modules/webdatabase/DatabaseBackendSync.cpp:

(WebCore::DatabaseBackendSync::openAndVerifyVersion):

  • Modules/webdatabase/DatabaseContext.cpp:

(WebCore::DatabaseContext::databaseExceededQuota):

  • Modules/webdatabase/DatabaseManager.cpp:
  • Modules/webdatabase/DatabaseManager.h:

(DatabaseManager):

  • Modules/webdatabase/DatabaseServer.cpp:

(WebCore::DatabaseServer::initialize):
(WebCore::DatabaseServer::setClient):
(WebCore::DatabaseServer::databaseDirectoryPath):
(WebCore::DatabaseServer::setDatabaseDirectoryPath):
(WebCore::DatabaseServer::openDatabase):

  • Modules/webdatabase/DatabaseServer.h:
  • Modules/webdatabase/DatabaseSync.cpp:

(WebCore::DatabaseSync::changeVersion):

  • Modules/webdatabase/DatabaseTracker.cpp:

(WebCore::DatabaseTracker::canEstablishDatabase):
(WebCore::DatabaseTracker::retryCanEstablishDatabase):

  • Modules/webdatabase/DatabaseTracker.h:

(WebCore):
(DatabaseTracker):

  • Modules/webdatabase/SQLStatementBackend.cpp:

(WebCore::SQLStatementBackend::execute):
(WebCore::SQLStatementBackend::setDatabaseDeletedError):
(WebCore::SQLStatementBackend::setVersionMismatchedError):
(WebCore::SQLStatementBackend::setFailureDueToQuota):

  • Modules/webdatabase/SQLStatementBackend.h:

(SQLStatementBackend):

  • Modules/webdatabase/SQLTransaction.cpp:

(WebCore::SQLTransaction::deliverTransactionCallback):
(WebCore::SQLTransaction::deliverStatementCallback):

  • Modules/webdatabase/SQLTransactionBackend.cpp:

(WebCore::SQLTransactionBackend::executeSQL):
(WebCore::SQLTransactionBackend::openTransactionAndPreflight):
(WebCore::SQLTransactionBackend::runCurrentStatementAndGetNextState):
(WebCore::SQLTransactionBackend::nextStateForCurrentStatementError):
(WebCore::SQLTransactionBackend::postflightAndCommit):
(WebCore::SQLTransactionBackend::acquireOriginLock):
(WebCore::SQLTransactionBackend::releaseOriginLockIfNeeded):

  • Modules/webdatabase/SQLTransactionBackend.h:

(SQLTransactionBackend):

  • Modules/webdatabase/SQLTransactionBackendSync.cpp:

(WebCore::SQLTransactionBackendSync::begin):
(WebCore::SQLTransactionBackendSync::commit):

Location:
trunk/Source/WebCore
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r147795 r147796  
     12013-04-05  Benjamin Poulain  <benjamin@webkit.org>
     2
     3        Clean the chromium bits of WebCore's WebDatabase
     4        https://bugs.webkit.org/show_bug.cgi?id=114010
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        * Modules/webdatabase/AbstractDatabaseServer.h:
     9        * Modules/webdatabase/ChangeVersionWrapper.cpp:
     10        (WebCore::ChangeVersionWrapper::performPreflight):
     11        (WebCore::ChangeVersionWrapper::performPostflight):
     12        * Modules/webdatabase/Database.cpp:
     13        * Modules/webdatabase/Database.h:
     14        (Database):
     15        * Modules/webdatabase/DatabaseBackend.cpp:
     16        (WebCore::DatabaseBackend::openAndVerifyVersion):
     17        * Modules/webdatabase/DatabaseBackendBase.cpp:
     18        (WebCore::DoneCreatingDatabaseOnExitCaller::~DoneCreatingDatabaseOnExitCaller):
     19        (WebCore::DatabaseBackendBase::performOpenAndVerify):
     20        (WebCore::DatabaseBackendBase::getActualVersionForTransaction):
     21        (WebCore::DatabaseBackendBase::incrementalVacuumIfNeeded):
     22        * Modules/webdatabase/DatabaseBackendBase.h:
     23        (DatabaseBackendBase):
     24        * Modules/webdatabase/DatabaseBackendSync.cpp:
     25        (WebCore::DatabaseBackendSync::openAndVerifyVersion):
     26        * Modules/webdatabase/DatabaseContext.cpp:
     27        (WebCore::DatabaseContext::databaseExceededQuota):
     28        * Modules/webdatabase/DatabaseManager.cpp:
     29        * Modules/webdatabase/DatabaseManager.h:
     30        (DatabaseManager):
     31        * Modules/webdatabase/DatabaseServer.cpp:
     32        (WebCore::DatabaseServer::initialize):
     33        (WebCore::DatabaseServer::setClient):
     34        (WebCore::DatabaseServer::databaseDirectoryPath):
     35        (WebCore::DatabaseServer::setDatabaseDirectoryPath):
     36        (WebCore::DatabaseServer::openDatabase):
     37        * Modules/webdatabase/DatabaseServer.h:
     38        * Modules/webdatabase/DatabaseSync.cpp:
     39        (WebCore::DatabaseSync::changeVersion):
     40        * Modules/webdatabase/DatabaseTracker.cpp:
     41        (WebCore::DatabaseTracker::canEstablishDatabase):
     42        (WebCore::DatabaseTracker::retryCanEstablishDatabase):
     43        * Modules/webdatabase/DatabaseTracker.h:
     44        (WebCore):
     45        (DatabaseTracker):
     46        * Modules/webdatabase/SQLStatementBackend.cpp:
     47        (WebCore::SQLStatementBackend::execute):
     48        (WebCore::SQLStatementBackend::setDatabaseDeletedError):
     49        (WebCore::SQLStatementBackend::setVersionMismatchedError):
     50        (WebCore::SQLStatementBackend::setFailureDueToQuota):
     51        * Modules/webdatabase/SQLStatementBackend.h:
     52        (SQLStatementBackend):
     53        * Modules/webdatabase/SQLTransaction.cpp:
     54        (WebCore::SQLTransaction::deliverTransactionCallback):
     55        (WebCore::SQLTransaction::deliverStatementCallback):
     56        * Modules/webdatabase/SQLTransactionBackend.cpp:
     57        (WebCore::SQLTransactionBackend::executeSQL):
     58        (WebCore::SQLTransactionBackend::openTransactionAndPreflight):
     59        (WebCore::SQLTransactionBackend::runCurrentStatementAndGetNextState):
     60        (WebCore::SQLTransactionBackend::nextStateForCurrentStatementError):
     61        (WebCore::SQLTransactionBackend::postflightAndCommit):
     62        (WebCore::SQLTransactionBackend::acquireOriginLock):
     63        (WebCore::SQLTransactionBackend::releaseOriginLockIfNeeded):
     64        * Modules/webdatabase/SQLTransactionBackend.h:
     65        (SQLTransactionBackend):
     66        * Modules/webdatabase/SQLTransactionBackendSync.cpp:
     67        (WebCore::SQLTransactionBackendSync::begin):
     68        (WebCore::SQLTransactionBackendSync::commit):
     69
    1702013-04-05  Geoffrey Garen  <ggaren@apple.com>
    271

  • trunk/Source/WebCore/Modules/webdatabase/AbstractDatabaseServer.h

    r144006 r147796  
    6262        bool setVersionInNewDatabase, DatabaseError&, String& errorMessage, OpenAttempt = FirstTryToOpenDatabase) = 0;
    6363
    64 #if !PLATFORM(CHROMIUM)
    6564    virtual bool hasEntryForOrigin(SecurityOrigin*) = 0;
    6665    virtual void origins(Vector<RefPtr<SecurityOrigin> >& result) = 0;
    … …  
    7776    virtual bool deleteDatabase(SecurityOrigin*, const String& name) = 0;
    7877
    79 #else // PLATFORM(CHROMIUM)
    80     virtual void closeDatabasesImmediately(const String& originIdentifier, const String& name) = 0;
    81 #endif // PLATFORM(CHROMIUM)
    82 
    8378    virtual void interruptAllDatabasesForContext(const DatabaseBackendContext*) = 0;
    8479

  • trunk/Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.cpp

    r143551 r147796  
    5353    if (!database->getVersionFromDatabase(actualVersion)) {
    5454        int sqliteError = database->sqliteDatabase().lastError();
    55         database->reportChangeVersionResult(1, SQLError::UNKNOWN_ERR, sqliteError);
    5655        m_sqlError = SQLError::create(SQLError::UNKNOWN_ERR, "unable to read the current version",
    5756                                      sqliteError, database->sqliteDatabase().lastErrorMsg());
    … …  
    6059
    6160    if (actualVersion != m_oldVersion) {
    62         database->reportChangeVersionResult(2, SQLError::VERSION_ERR, 0);
    6361        m_sqlError = SQLError::create(SQLError::VERSION_ERR, "current version of the database and `oldVersion` argument do not match");
    6462        return false;
    … …  
    7674    if (!database->setVersionInDatabase(m_newVersion)) {
    7775        int sqliteError = database->sqliteDatabase().lastError();
    78         database->reportChangeVersionResult(3, SQLError::UNKNOWN_ERR, sqliteError);
    7976        m_sqlError = SQLError::create(SQLError::UNKNOWN_ERR, "unable to set new version in database",
    8077                                      sqliteError, database->sqliteDatabase().lastErrorMsg());
    … …  
    8380
    8481    database->setExpectedVersion(m_newVersion);
    85 
    86     database->reportChangeVersionResult(0, -1, 0); // OK
    8782    return true;
    8883}

  • trunk/Source/WebCore/Modules/webdatabase/Database.cpp

    r147795 r147796  
    284284}
    285285
    286 #if PLATFORM(CHROMIUM)
    287 void Database::reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
    288 {
    289     backend()->reportStartTransactionResult(errorSite, webSqlErrorCode, sqliteErrorCode);
    290 }
    291 
    292 void Database::reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
    293 {
    294     backend()->reportCommitTransactionResult(errorSite, webSqlErrorCode, sqliteErrorCode);
    295 }
    296 
    297 #endif
    298 
    299286} // namespace WebCore
    300287

  • trunk/Source/WebCore/Modules/webdatabase/Database.h

    r144006 r147796  
    8787    Vector<String> performGetTableNames();
    8888
    89 #if PLATFORM(CHROMIUM)
    90     void reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
    91     void reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
    92 #else
    93     void reportStartTransactionResult(int, int, int) { }
    94     void reportCommitTransactionResult(int, int, int) { }
    95 #endif
    96 
    9789    RefPtr<SecurityOrigin> m_databaseThreadSecurityOrigin;
    9890    RefPtr<DatabaseContext> m_databaseContext;

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp

    r143551 r147796  
    5656        return false;
    5757
    58 #if PLATFORM(CHROMIUM)
    59     DatabaseTracker::tracker().prepareToOpenDatabase(this);
    60 #endif
    6158    bool success = false;
    6259    OwnPtr<DatabaseOpenTask> task = DatabaseOpenTask::create(this, setVersionInNewDatabase, &synchronizer, error, errorMessage, success);

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp

    r144006 r147796  
    5252#include <wtf/text/StringHash.h>
    5353
    54 #if PLATFORM(CHROMIUM)
    55 #include "DatabaseObserver.h" // For error reporting.
    56 #endif
    57 
    5854// Registering "opened" databases with the DatabaseTracker
    5955// =======================================================
    … …  
    295291    ~DoneCreatingDatabaseOnExitCaller()
    296292    {
    297 #if !PLATFORM(CHROMIUM)
    298293        DatabaseTracker::tracker().doneCreatingDatabase(m_database);
    299 #else
    300         if (!m_openSucceeded)
    301             DatabaseTracker::tracker().failedToOpenDatabase(m_database);
    302 #endif           
    303294    }
    304295
    … …  
    320311
    321312    if (!m_sqliteDatabase.open(m_filename, true)) {
    322         reportOpenDatabaseResult(1, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
    323313        errorMessage = formatErrorMessage("unable to open database", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
    324314        return false;
    … …  
    338328            currentVersion = entry->value.isNull() ? emptyString() : entry->value.isolatedCopy();
    339329            LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
    340 
    341 #if PLATFORM(CHROMIUM)
    342             // Note: In multi-process browsers the cached value may be inaccurate, but
    343             // we cannot read the actual version from the database without potentially
    344             // inducing a form of deadlock, a busytimeout error when trying to
    345             // access the database. So we'll use the cached value if we're unable to read
    346             // the value from the database file without waiting.
    347             // FIXME: Add an async openDatabase method to the DatabaseAPI.
    348             const int noSqliteBusyWaitTime = 0;
    349             m_sqliteDatabase.setBusyTimeout(noSqliteBusyWaitTime);
    350             String versionFromDatabase;
    351             if (getVersionFromDatabase(versionFromDatabase, false)) {
    352                 currentVersion = versionFromDatabase;
    353                 updateGuidVersionMap(m_guid, currentVersion);
    354             }
    355             m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
    356 #endif
    357330        } else {
    358331            LOG(StorageAPI, "No cached version for guid %i", m_guid);
    … …  
    361334            transaction.begin();
    362335            if (!transaction.inProgress()) {
    363                 reportOpenDatabaseResult(2, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
    364336                errorMessage = formatErrorMessage("unable to open database, failed to start transaction", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
    365337                m_sqliteDatabase.close();
    … …  
    372344
    373345                if (!m_sqliteDatabase.executeCommand("CREATE TABLE " + tableName + " (key TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,value TEXT NOT NULL ON CONFLICT FAIL);")) {
    374                     reportOpenDatabaseResult(3, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
    375346                    errorMessage = formatErrorMessage("unable to open database, failed to create 'info' table", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
    376347                    transaction.rollback();
    … …  
    379350                }
    380351            } else if (!getVersionFromDatabase(currentVersion, false)) {
    381                 reportOpenDatabaseResult(4, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
    382352                errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
    383353                transaction.rollback();
    … …  
    391361                LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
    392362                if (!setVersionInDatabase(m_expectedVersion, false)) {
    393                     reportOpenDatabaseResult(5, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
    394363                    errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
    395364                    transaction.rollback();
    … …  
    412381    // If the expected version is the empty string, then we always return with whatever version of the database we have.
    413382    if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
    414         reportOpenDatabaseResult(6, INVALID_STATE_ERR, 0);
    415383        errorMessage = "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'";
    416384        m_sqliteDatabase.close();
    … …  
    431399    if (m_new && !shouldSetVersionInNewDatabase)
    432400        m_expectedVersion = ""; // The caller provided a creationCallback which will set the expected version.
    433 
    434     reportOpenDatabaseResult(0, -1, 0); // OK
    435401    return true;
    436402}
    … …  
    528494{
    529495    ASSERT(m_sqliteDatabase.transactionInProgress());
    530 #if PLATFORM(CHROMIUM)
    531496    // Note: In multi-process browsers the cached value may be inaccurate.
    532497    // So we retrieve the value from the database and update the cached value here.
    533498    return getVersionFromDatabase(actualVersion, true);
    534 #else
    535     actualVersion = getCachedVersion();
    536     return true;
    537 #endif
    538499}
    539500
    … …  
    603564    if (totalSize <= 10 * freeSpaceSize) {
    604565        int result = m_sqliteDatabase.runIncrementalVacuumCommand();
    605         reportVacuumDatabaseResult(result);
    606566        if (result != SQLResultOk)
    607567            m_frontend->logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
    … …  
    620580}
    621581
    622 #if PLATFORM(CHROMIUM)
    623 // These are used to generate histograms of errors seen with websql.
    624 // See about:histograms in chromium.
    625 void DatabaseBackendBase::reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
    626 {
    627     DatabaseObserver::reportOpenDatabaseResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
    628 }
    629 
    630 void DatabaseBackendBase::reportChangeVersionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
    631 {
    632     DatabaseObserver::reportChangeVersionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
    633 }
    634 
    635 void DatabaseBackendBase::reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
    636 {
    637     DatabaseObserver::reportStartTransactionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
    638 }
    639 
    640 void DatabaseBackendBase::reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
    641 {
    642     DatabaseObserver::reportCommitTransactionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
    643 }
    644 
    645 void DatabaseBackendBase::reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
    646 {
    647     DatabaseObserver::reportExecuteStatementResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
    648 }
    649 
    650 void DatabaseBackendBase::reportVacuumDatabaseResult(int sqliteErrorCode)
    651 {
    652     DatabaseObserver::reportVacuumDatabaseResult(this, sqliteErrorCode);
    653 }
    654 
    655 #endif // PLATFORM(CHROMIUM)
    656 
    657582} // namespace WebCore
    658583

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendBase.h

    r143471 r147796  
    115115    bool getActualVersionForTransaction(String& version);
    116116
    117 #if PLATFORM(CHROMIUM)
    118     void reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
    119     void reportChangeVersionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
    120     void reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
    121     void reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
    122     void reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
    123     void reportVacuumDatabaseResult(int sqliteErrorCode);
    124 #else
    125     void reportOpenDatabaseResult(int, int, int) { }
    126     void reportChangeVersionResult(int, int, int) { }
    127     void reportStartTransactionResult(int, int, int) { }
    128     void reportCommitTransactionResult(int, int, int) { }
    129     void reportExecuteStatementResult(int, int, int) { }
    130     void reportVacuumDatabaseResult(int) { }
    131 #endif
    132 
    133117    static const char* databaseInfoTableName();
    134118

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendSync.cpp

    r143471 r147796  
    5555bool DatabaseBackendSync::openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
    5656{
    57 #if PLATFORM(CHROMIUM)
    58     DatabaseTracker::tracker().prepareToOpenDatabase(this);
    59 #endif
    6057    return performOpenAndVerify(setVersionInNewDatabase, error, errorMessage);
    6158}

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseContext.cpp

    r146537 r147796  
    225225    }
    226226    ASSERT(m_scriptExecutionContext->isWorkerContext());
    227 #if !PLATFORM(CHROMIUM)
    228227    // FIXME: This needs a real implementation; this is a temporary solution for testing.
    229228    const unsigned long long defaultQuota = 5 * 1024 * 1024;
    230229    DatabaseManager::manager().setQuota(m_scriptExecutionContext->securityOrigin(), defaultQuota);
    231 #endif
    232230}
    233231

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseManager.cpp

    r144949 r147796  
    364364}
    365365
    366 #if !PLATFORM(CHROMIUM)
    367366bool DatabaseManager::hasEntryForOrigin(SecurityOrigin* origin)
    368367{
    … …  
    414413    return m_server->deleteDatabase(origin, name);
    415414}
    416 
    417 #else // PLATFORM(CHROMIUM)
    418 void DatabaseManager::closeDatabasesImmediately(const String& originIdentifier, const String& name)
    419 {
    420     m_server->closeDatabasesImmediately(originIdentifier, name);
    421 }
    422 #endif // PLATFORM(CHROMIUM)
    423415
    424416void DatabaseManager::interruptAllDatabasesForContext(ScriptExecutionContext* context)

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseManager.h

    r144006 r147796  
    9090    String fullPathForDatabase(SecurityOrigin*, const String& name, bool createIfDoesNotExist = true);
    9191
    92 #if !PLATFORM(CHROMIUM)
    9392    bool hasEntryForOrigin(SecurityOrigin*);
    9493    void origins(Vector<RefPtr<SecurityOrigin> >& result);
    … …  
    104103    bool deleteOrigin(SecurityOrigin*);
    105104    bool deleteDatabase(SecurityOrigin*, const String& name);
    106 
    107 #else // PLATFORM(CHROMIUM)
    108     void closeDatabasesImmediately(const String& originIdentifier, const String& name);
    109 #endif // PLATFORM(CHROMIUM)
    110105
    111106    void interruptAllDatabasesForContext(ScriptExecutionContext*);

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseServer.cpp

    r144006 r147796  
    4141void DatabaseServer::initialize(const String& databasePath)
    4242{
    43 #if !PLATFORM(CHROMIUM)
    4443    DatabaseTracker::initializeTracker(databasePath);
    45 #else
    46     UNUSED_PARAM(databasePath);
    47 #endif
    4844}
    4945
    5046void DatabaseServer::setClient(DatabaseManagerClient* client)
    5147{
    52 #if !PLATFORM(CHROMIUM)
    5348    DatabaseTracker::tracker().setClient(client);
    54 #else
    55     UNUSED_PARAM(client);
    56 #endif
    5749}
    5850
    5951String DatabaseServer::databaseDirectoryPath() const
    6052{
    61 #if !PLATFORM(CHROMIUM)
    6253    return DatabaseTracker::tracker().databaseDirectoryPath();
    63 #else
    64     return "";
    65 #endif
    6654}
    6755
    6856void DatabaseServer::setDatabaseDirectoryPath(const String& path)
    6957{
    70 #if !PLATFORM(CHROMIUM)
    7158    DatabaseTracker::tracker().setDatabaseDirectoryPath(path);
    72 #endif
    7359}
    7460
    … …  
    7864}
    7965
    80 #if !PLATFORM(CHROMIUM)
    8166bool DatabaseServer::hasEntryForOrigin(SecurityOrigin* origin)
    8267{
    … …  
    129114}
    130115
    131 #else // PLATFORM(CHROMIUM)
    132 void DatabaseServer::closeDatabasesImmediately(const String& originIdentifier, const String& name)
    133 {
    134     DatabaseTracker::tracker().closeDatabasesImmediately(originIdentifier, name);
    135 }
    136 #endif // PLATFORM(CHROMIUM)
    137 
    138116void DatabaseServer::interruptAllDatabasesForContext(const DatabaseBackendContext* context)
    139117{
    … …  
    151129    switch (attempt) {
    152130    case FirstTryToOpenDatabase:
    153         success = DatabaseTracker::tracker().canEstablishDatabase(backendContext.get(), name, displayName, estimatedSize, error);
     131        success = DatabaseTracker::tracker().canEstablishDatabase(backendContext.get(), name, estimatedSize, error);
    154132        break;
    155133    case RetryOpenDatabase:
    156         success = DatabaseTracker::tracker().retryCanEstablishDatabase(backendContext.get(), name, displayName, estimatedSize, error);
     134        success = DatabaseTracker::tracker().retryCanEstablishDatabase(backendContext.get(), name, estimatedSize, error);
    157135    }
    158136

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseServer.h

    r144006 r147796  
    5050        bool setVersionInNewDatabase, DatabaseError&, String& errorMessage, OpenAttempt);
    5151
    52 #if !PLATFORM(CHROMIUM)
    5352    virtual bool hasEntryForOrigin(SecurityOrigin*);
    5453    virtual void origins(Vector<RefPtr<SecurityOrigin> >& result);
    … …  
    6564    virtual bool deleteDatabase(SecurityOrigin*, const String& name);
    6665
    67 #else // PLATFORM(CHROMIUM)
    68     virtual void closeDatabasesImmediately(const String& originIdentifier, const String& name);
    69 #endif // PLATFORM(CHROMIUM)
    70 
    7166    virtual void interruptAllDatabasesForContext(const DatabaseBackendContext*);
    7267

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseSync.cpp

    r143471 r147796  
    8080
    8181    if (sqliteDatabase().transactionInProgress()) {
    82         reportChangeVersionResult(1, SQLException::DATABASE_ERR, 0);
    8382        setLastErrorMessage("unable to changeVersion from within a transaction");
    8483        ec = SQLException::DATABASE_ERR;
    … …  
    9493    String actualVersion;
    9594    if (!getVersionFromDatabase(actualVersion)) {
    96         reportChangeVersionResult(2, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
    9795        setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
    9896        ec = SQLException::UNKNOWN_ERR;
    … …  
    10199
    102100    if (actualVersion != oldVersion) {
    103         reportChangeVersionResult(3, SQLException::VERSION_ERR, 0);
    104101        setLastErrorMessage("current version of the database and `oldVersion` argument do not match");
    105102        ec = SQLException::VERSION_ERR;
    … …  
    113110
    114111    if (!setVersionInDatabase(newVersion)) {
    115         reportChangeVersionResult(4, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
    116112        setLastErrorMessage("unable to set the new version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
    117113        ec = SQLException::UNKNOWN_ERR;
    … …  
    124120        return;
    125121    }
    126 
    127     reportChangeVersionResult(0, -1, 0); // OK
    128122
    129123    setExpectedVersion(newVersion);

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTracker.cpp

    r145431 r147796  
    157157}
    158158
    159 bool DatabaseTracker::canEstablishDatabase(DatabaseBackendContext* context, const String& name, const String& displayName, unsigned long estimatedSize, DatabaseError& error)
    160 {
    161     UNUSED_PARAM(displayName); // Chromium needs the displayName but we don't.
     159bool DatabaseTracker::canEstablishDatabase(DatabaseBackendContext* context, const String& name, unsigned long estimatedSize, DatabaseError& error)
     160{
    162161    error = DatabaseError::None;
    163162
    … …  
    210209// re-use it. Also note that the path for opening a database involves IO, and
    211210// hence should not be a performance critical path anyway.
    212 bool DatabaseTracker::retryCanEstablishDatabase(DatabaseBackendContext* context, const String& name, const String& displayName, unsigned long estimatedSize, DatabaseError& error)
    213 {
    214     // Chromium needs the displayName in canEstablishDatabase(), but we don't.
    215     // Though Chromium does not use retryCanEstablishDatabase(), we should
    216     // keep the prototypes for canEstablishDatabase() and its retry function
    217     // the same. Hence, we also have an unneeded displayName arg here.
    218     UNUSED_PARAM(displayName);
     211bool DatabaseTracker::retryCanEstablishDatabase(DatabaseBackendContext* context, const String& name, unsigned long estimatedSize, DatabaseError& error)
     212{
    219213    error = DatabaseError::None;
    220214

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTracker.h

    r145431 r147796  
    3232#if ENABLE(SQL_DATABASE)
    3333
     34#include "DatabaseDetails.h"
    3435#include "DatabaseError.h"
     36#include "SQLiteDatabase.h"
     37#include "SecurityOriginHash.h"
    3538#include <wtf/HashMap.h>
    3639#include <wtf/HashSet.h>
     40#include <wtf/OwnPtr.h>
    3741#include <wtf/text/StringHash.h>
    3842#include <wtf/text/WTFString.h>
    39 
    40 #if !PLATFORM(CHROMIUM)
    41 #include "DatabaseDetails.h"
    42 #include "SQLiteDatabase.h"
    43 #include "SecurityOriginHash.h"
    44 #include <wtf/OwnPtr.h>
    45 #endif // !PLATFORM(CHROMIUM)
    4643
    4744namespace WebCore {
    … …  
    4946class DatabaseBackendBase;
    5047class DatabaseBackendContext;
     48class DatabaseManagerClient;
    5149class OriginLock;
    5250class SecurityOrigin;
    53 
    54 #if !PLATFORM(CHROMIUM)
    55 class DatabaseManagerClient;
    56 
    57 #endif // !PLATFORM(CHROMIUM)
    5851
    5952class DatabaseTracker {
    6053    WTF_MAKE_NONCOPYABLE(DatabaseTracker); WTF_MAKE_FAST_ALLOCATED;
    6154public:
    62 #if !PLATFORM(CHROMIUM)
    6355    static void initializeTracker(const String& databasePath);
    64 #endif
     56
    6557    static DatabaseTracker& tracker();
    6658    // This singleton will potentially be used from multiple worker threads and the page's context thread simultaneously.  To keep this safe, it's
    … …  
    7163    // notificationMutex() is currently independent of the other locks.
    7264
    73     bool canEstablishDatabase(DatabaseBackendContext*, const String& name, const String& displayName, unsigned long estimatedSize, DatabaseError&);
    74     bool retryCanEstablishDatabase(DatabaseBackendContext*, const String& name, const String& displayName, unsigned long estimatedSize, DatabaseError&);
     65    bool canEstablishDatabase(DatabaseBackendContext*, const String& name, unsigned long estimatedSize, DatabaseError&);
     66    bool retryCanEstablishDatabase(DatabaseBackendContext*, const String& name, unsigned long estimatedSize, DatabaseError&);
    7567
    7668    void setDatabaseDetails(SecurityOrigin*, const String& name, const String& displayName, unsigned long estimatedSize);
    … …  
    9082    bool hasAdequateQuotaForOrigin(SecurityOrigin*, unsigned long estimatedSize, DatabaseError&);
    9183
    92 #if !PLATFORM(CHROMIUM)
    9384public:
    9485    void setDatabaseDirectoryPath(const String&);
    … …  
    182173    static void scheduleForNotification();
    183174    static void notifyDatabasesChanged(void*);
    184 #else // PLATFORM(CHROMIUM)
    185 public:
    186     void closeDatabasesImmediately(const String& originIdentifier, const String& name);
    187 
    188     void prepareToOpenDatabase(DatabaseBackendBase*);
    189     void failedToOpenDatabase(DatabaseBackendBase*);
    190 
    191 private:
    192     typedef HashSet<DatabaseBackendBase*> DatabaseSet;
    193     typedef HashMap<String, DatabaseSet*> DatabaseNameMap;
    194     typedef HashMap<String, DatabaseNameMap*> DatabaseOriginMap;
    195     class CloseOneDatabaseImmediatelyTask;
    196 
    197     void closeOneDatabaseImmediately(const String& originIdentifier, const String& name, DatabaseBackendBase*);
    198 
    199     Mutex m_openDatabaseMapGuard;
    200     mutable OwnPtr<DatabaseOriginMap> m_openDatabaseMap;
    201 #endif // PLATFORM(CHROMIUM)
    202175};
    203176

  • trunk/Source/WebCore/Modules/webdatabase/SQLStatementBackend.cpp

    r143551 r147796  
    133133        else
    134134            m_error = SQLError::create(SQLError::SYNTAX_ERR, "could not prepare statement", result, database->lastErrorMsg());
    135         db->reportExecuteStatementResult(1, m_error->code(), result);
    136135        return false;
    137136    }
    … …  
    142141        LOG(StorageAPI, "Bind parameter count doesn't match number of question marks");
    143142        m_error = SQLError::create(db->isInterrupted() ? SQLError::DATABASE_ERR : SQLError::SYNTAX_ERR, "number of '?'s in statement string does not match argument count");
    144         db->reportExecuteStatementResult(2, m_error->code(), 0);
    145143        return false;
    146144    }
    … …  
    149147        result = statement.bindValue(i + 1, m_arguments[i]);
    150148        if (result == SQLResultFull) {
    151             setFailureDueToQuota(db);
     149            setFailureDueToQuota();
    152150            return false;
    153151        }
    … …  
    155153        if (result != SQLResultOk) {
    156154            LOG(StorageAPI, "Failed to bind value index %i to statement for query '%s'", i + 1, m_statement.ascii().data());
    157             db->reportExecuteStatementResult(3, SQLError::DATABASE_ERR, result);
    158155            m_error = SQLError::create(SQLError::DATABASE_ERR, "could not bind value", result, database->lastErrorMsg());
    159156            return false;
    … …  
    180177
    181178        if (result != SQLResultDone) {
    182             db->reportExecuteStatementResult(4, SQLError::DATABASE_ERR, result);
    183179            m_error = SQLError::create(SQLError::DATABASE_ERR, "could not iterate results", result, database->lastErrorMsg());
    184180            return false;
    … …  
    190186    } else if (result == SQLResultFull) {
    191187        // Return the Quota error - the delegate will be asked for more space and this statement might be re-run
    192         setFailureDueToQuota(db);
     188        setFailureDueToQuota();
    193189        return false;
    194190    } else if (result == SQLResultConstraint) {
    195         db->reportExecuteStatementResult(6, SQLError::CONSTRAINT_ERR, result);
    196191        m_error = SQLError::create(SQLError::CONSTRAINT_ERR, "could not execute statement due to a constaint failure", result, database->lastErrorMsg());
    197192        return false;
    198193    } else {
    199         db->reportExecuteStatementResult(5, SQLError::DATABASE_ERR, result);
    200194        m_error = SQLError::create(SQLError::DATABASE_ERR, "could not execute statement", result, database->lastErrorMsg());
    201195        return false;
    … …  
    208202
    209203    m_resultSet = resultSet;
    210     db->reportExecuteStatementResult(0, -1, 0); // OK
    211204    return true;
    212205}
    213206
    214 void SQLStatementBackend::setDatabaseDeletedError(DatabaseBackend* database)
     207void SQLStatementBackend::setDatabaseDeletedError()
    215208{
    216209    ASSERT(!m_error && !m_resultSet);
    217     database->reportExecuteStatementResult(6, SQLError::UNKNOWN_ERR, 0);
    218210    m_error = SQLError::create(SQLError::UNKNOWN_ERR, "unable to execute statement, because the user deleted the database");
    219211}
    220212
    221 void SQLStatementBackend::setVersionMismatchedError(DatabaseBackend* database)
     213void SQLStatementBackend::setVersionMismatchedError()
    222214{
    223215    ASSERT(!m_error && !m_resultSet);
    224     database->reportExecuteStatementResult(7, SQLError::VERSION_ERR, 0);
    225216    m_error = SQLError::create(SQLError::VERSION_ERR, "current version of the database and `oldVersion` argument do not match");
    226217}
    227218
    228 void SQLStatementBackend::setFailureDueToQuota(DatabaseBackend* database)
     219void SQLStatementBackend::setFailureDueToQuota()
    229220{
    230221    ASSERT(!m_error && !m_resultSet);
    231     database->reportExecuteStatementResult(8, SQLError::QUOTA_ERR, 0);
    232222    m_error = SQLError::create(SQLError::QUOTA_ERR, "there was not enough remaining storage space, or the storage quota was reached and the user declined to allow more space");
    233223}

  • trunk/Source/WebCore/Modules/webdatabase/SQLStatementBackend.h

    r143551 r147796  
    5656    bool hasStatementErrorCallback() const { return m_hasErrorCallback; }
    5757
    58     void setDatabaseDeletedError(DatabaseBackend*);
    59     void setVersionMismatchedError(DatabaseBackend*);
     58    void setDatabaseDeletedError();
     59    void setVersionMismatchedError();
    6060
    6161    AbstractSQLStatement* frontend();
    … …  
    6767        const Vector<SQLValue>& arguments, int permissions);
    6868
    69     void setFailureDueToQuota(DatabaseBackend*);
     69    void setFailureDueToQuota();
    7070    void clearFailureDueToQuota();
    7171

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransaction.cpp

    r143489 r147796  
    151151    SQLTransactionState nextState = SQLTransactionState::RunStatements;
    152152    if (shouldDeliverErrorCallback) {
    153         m_database->reportStartTransactionResult(5, SQLError::UNKNOWN_ERR, 0);
    154153        m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the SQLTransactionCallback was null or threw an exception");
    155154        nextState = SQLTransactionState::DeliverTransactionErrorCallback;
    156155    }
    157     m_database->reportStartTransactionResult(0, -1, 0); // OK
    158156    return nextState;
    159157}
    … …  
    199197
    200198    if (result) {
    201         m_database->reportCommitTransactionResult(2, SQLError::UNKNOWN_ERR, 0);
    202199        m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the statement callback raised an exception or statement error callback did not return false");
    203200        return nextStateForTransactionError();

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

    r144760 r147796  
    532532
    533533    if (Database::from(m_database.get())->deleted())
    534         statementBackend->setDatabaseDeletedError(m_database.get());
     534        statementBackend->setDatabaseDeletedError();
    535535
    536536    enqueueStatementBackend(statementBackend);
    … …  
    570570    // If the database was deleted, jump to the error callback
    571571    if (Database::from(m_database.get())->deleted()) {
    572         m_database->reportStartTransactionResult(1, SQLError::UNKNOWN_ERR, 0);
    573572        m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unable to open a transaction, because the user deleted the database");
    574573        return nextStateForTransactionError();
    … …  
    592591    if (!m_sqliteTransaction->inProgress()) {
    593592        ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    594         m_database->reportStartTransactionResult(2, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    595593        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to begin transaction",
    596594            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    … …  
    604602    String actualVersion;
    605603    if (!m_database->getActualVersionForTransaction(actualVersion)) {
    606         m_database->reportStartTransactionResult(3, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    607604        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to read version",
    608605            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    … …  
    620617        m_database->enableAuthorizer();
    621618        m_transactionError = m_wrapper->sqlError();
    622         if (!m_transactionError) {
    623             m_database->reportStartTransactionResult(4, SQLError::UNKNOWN_ERR, 0);
     619        if (!m_transactionError)
    624620            m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction preflight");
    625         }
    626621        return nextStateForTransactionError();
    627622    }
    … …  
    688683
    689684    if (m_hasVersionMismatch)
    690         m_currentStatementBackend->setVersionMismatchedError(Database::from(m_database.get()));
     685        m_currentStatementBackend->setVersionMismatchedError();
    691686
    692687    if (m_currentStatementBackend->execute(m_database.get())) {
    … …  
    720715
    721716    m_transactionError = m_currentStatementBackend->sqlError();
    722     if (!m_transactionError) {
    723         m_database->reportCommitTransactionResult(1, SQLError::DATABASE_ERR, 0);
     717    if (!m_transactionError)
    724718        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "the statement failed to execute");
    725     }
    726719    return nextStateForTransactionError();
    727720}
    … …  
    734727    if (m_wrapper && !m_wrapper->performPostflight(this)) {
    735728        m_transactionError = m_wrapper->sqlError();
    736         if (!m_transactionError) {
    737             m_database->reportCommitTransactionResult(3, SQLError::UNKNOWN_ERR, 0);
     729        if (!m_transactionError)
    738730            m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction postflight");
    739         }
    740731        return nextStateForTransactionError();
    741732    }
    … …  
    754745        if (m_wrapper)
    755746            m_wrapper->handleCommitFailedAfterPostflight(this);
    756         m_database->reportCommitTransactionResult(4, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    757747        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to commit transaction",
    758748            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    759749        return nextStateForTransactionError();
    760750    }
    761 
    762     m_database->reportCommitTransactionResult(0, -1, 0); // OK
    763751
    764752    // Vacuum the database if anything was deleted.
    … …  
    850838void SQLTransactionBackend::acquireOriginLock()
    851839{
    852 #if !PLATFORM(CHROMIUM)
    853840    ASSERT(!m_originLock);
    854841    m_originLock = DatabaseTracker::tracker().originLockFor(m_database->securityOrigin());
    855842    m_originLock->lock();
    856 #endif
    857843}
    858844
    859845void SQLTransactionBackend::releaseOriginLockIfNeeded()
    860846{
    861 #if !PLATFORM(CHROMIUM)
    862847    if (m_originLock) {
    863848        m_originLock->unlock();
    864849        m_originLock.clear();
    865850    }
    866 #endif
    867851}
    868852

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h

    r144760 r147796  
    133133
    134134    OwnPtr<SQLiteTransaction> m_sqliteTransaction;
    135 #if !PLATFORM(CHROMIUM)
    136135    RefPtr<OriginLock> m_originLock;
    137 #endif
    138136};
    139137

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackendSync.cpp

    r144006 r147796  
    132132    ASSERT(m_database->scriptExecutionContext()->isContextThread());
    133133    if (!m_database->opened()) {
    134         m_database->reportStartTransactionResult(1, SQLException::UNKNOWN_ERR, 0);
    135134        m_database->setLastErrorMessage("cannot begin transaction because the database is not open");
    136135        return SQLException::UNKNOWN_ERR;
    … …  
    154153    if (!m_sqliteTransaction->inProgress()) {
    155154        ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    156         m_database->reportStartTransactionResult(2, SQLException::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    157155        m_database->setLastErrorMessage("unable to begin transaction",
    158156            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    … …  
    166164    String actualVersion;
    167165    if (!m_database->getActualVersionForTransaction(actualVersion)) {
    168         m_database->reportStartTransactionResult(3, SQLException::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    169166        m_database->setLastErrorMessage("unable to read version",
    170167            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    … …  
    173170    }
    174171    m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
    175     m_database->reportStartTransactionResult(0, -1, 0); // OK
    176172    return 0;
    177173}
    … …  
    195191    ASSERT(m_database->scriptExecutionContext()->isContextThread());
    196192    if (!m_database->opened()) {
    197         m_database->reportCommitTransactionResult(1, SQLException::UNKNOWN_ERR, 0);
    198193        m_database->setLastErrorMessage("unable to commit transaction because the database is not open.");
    199194        return SQLException::UNKNOWN_ERR;
    … …  
    208203    // If the commit failed, the transaction will still be marked as "in progress"
    209204    if (m_sqliteTransaction->inProgress()) {
    210         m_database->reportCommitTransactionResult(2, SQLException::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    211205        m_database->setLastErrorMessage("unable to commit transaction",
    212206            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    … …  
    223217    if (m_modifiedDatabase)
    224218        m_transactionClient->didCommitWriteTransaction(database());
    225 
    226     m_database->reportCommitTransactionResult(0, -1, 0); // OK
    227219    return 0;
    228220}
Note: See TracChangeset for help on using the changeset viewer.