Changeset 187998 in webkit


Ignore:
Timestamp:
Aug 5, 2015 4:17:18 PM (9 years ago)
Author:
andersca@apple.com
Message:

Move more functions from DatabaseBackendBase to Database
​https://bugs.webkit.org/show_bug.cgi?id=147703

Reviewed by Tim Horton.

  • Modules/webdatabase/Database.cpp:

(WebCore::fullyQualifiedInfoTableName):
(WebCore::setTextValueInDatabase):
(WebCore::retrieveTextResultFromDatabase):
(WebCore::Database::getVersionFromDatabase):
(WebCore::Database::setVersionInDatabase):
(WebCore::Database::performGetTableNames):

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

(WebCore::DatabaseBackendBase::performOpenAndVerify):
(WebCore::DatabaseBackendBase::getActualVersionForTransaction):
(WebCore::DatabaseBackendBase::databaseInfoTableName): Deleted.
(WebCore::fullyQualifiedInfoTableName): Deleted.
(WebCore::retrieveTextResultFromDatabase): Deleted.
(WebCore::setTextValueInDatabase): Deleted.
(WebCore::DatabaseBackendBase::getVersionFromDatabase): Deleted.
(WebCore::DatabaseBackendBase::setVersionInDatabase): Deleted.

  • Modules/webdatabase/DatabaseBackendBase.h:
Location:
trunk/Source/WebCore
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r187997 r187998  
     12015-08-05  Anders Carlsson  <andersca@apple.com>
     2
     3        Move more functions from DatabaseBackendBase to Database
     4        https://bugs.webkit.org/show_bug.cgi?id=147703
     5
     6        Reviewed by Tim Horton.
     7
     8        * Modules/webdatabase/Database.cpp:
     9        (WebCore::fullyQualifiedInfoTableName):
     10        (WebCore::setTextValueInDatabase):
     11        (WebCore::retrieveTextResultFromDatabase):
     12        (WebCore::Database::getVersionFromDatabase):
     13        (WebCore::Database::setVersionInDatabase):
     14        (WebCore::Database::performGetTableNames):
     15        * Modules/webdatabase/Database.h:
     16        * Modules/webdatabase/DatabaseBackendBase.cpp:
     17        (WebCore::DatabaseBackendBase::performOpenAndVerify):
     18        (WebCore::DatabaseBackendBase::getActualVersionForTransaction):
     19        (WebCore::DatabaseBackendBase::databaseInfoTableName): Deleted.
     20        (WebCore::fullyQualifiedInfoTableName): Deleted.
     21        (WebCore::retrieveTextResultFromDatabase): Deleted.
     22        (WebCore::setTextValueInDatabase): Deleted.
     23        (WebCore::DatabaseBackendBase::getVersionFromDatabase): Deleted.
     24        (WebCore::DatabaseBackendBase::setVersionInDatabase): Deleted.
     25        * Modules/webdatabase/DatabaseBackendBase.h:
     26
    1272015-08-05  Alex Christensen  <achristensen@webkit.org>
    228

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

    r187996 r187998  
    5959namespace WebCore {
    6060
     61static const char versionKey[] = "WebKitDatabaseVersionKey";
     62static const char unqualifiedInfoTableName[] = "__WebKitDatabaseInfoTable__";
     63
     64static const char* fullyQualifiedInfoTableName()
     65{
     66    static const char qualifier[] = "main.";
     67    static char qualifiedName[sizeof(qualifier) + sizeof(unqualifiedInfoTableName) - 1];
     68
     69    static std::once_flag onceFlag;
     70    std::call_once(onceFlag, [] {
     71        strcpy(qualifiedName, qualifier);
     72        strcpy(qualifiedName + sizeof(qualifier) - 1, unqualifiedInfoTableName);
     73    });
     74
     75    return qualifiedName;
     76}
     77
    6178static String formatErrorMessage(const char* message, int sqliteErrorCode, const char* sqliteErrorMessage)
    6279{
    6380    return String::format("%s (%d %s)", message, sqliteErrorCode, sqliteErrorMessage);
     81}
     82
     83static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, const String& value)
     84{
     85    SQLiteStatement statement(db, query);
     86    int result = statement.prepare();
     87
     88    if (result != SQLITE_OK) {
     89        LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
     90        return false;
     91    }
     92
     93    statement.bindText(1, value);
     94
     95    result = statement.step();
     96    if (result != SQLITE_DONE) {
     97        LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
     98        return false;
     99    }
     100
     101    return true;
     102}
     103
     104static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& query, String& resultString)
     105{
     106    SQLiteStatement statement(db, query);
     107    int result = statement.prepare();
     108
     109    if (result != SQLITE_OK) {
     110        LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
     111        return false;
     112    }
     113
     114    result = statement.step();
     115    if (result == SQLITE_ROW) {
     116        resultString = statement.getColumnText(0);
     117        return true;
     118    }
     119    if (result == SQLITE_DONE) {
     120        resultString = String();
     121        return true;
     122    }
     123
     124    LOG_ERROR("Error (%i) reading text result from database (%s)", result, query.ascii().data());
     125    return false;
    64126}
    65127
    … …  
    152214}
    153215
     216bool Database::getVersionFromDatabase(String& version, bool shouldCacheVersion)
     217{
     218    String query(String("SELECT value FROM ") + fullyQualifiedInfoTableName() +  " WHERE key = '" + versionKey + "';");
     219
     220    m_databaseAuthorizer->disable();
     221
     222    bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, query, version);
     223    if (result) {
     224        if (shouldCacheVersion)
     225            setCachedVersion(version);
     226    } else
     227        LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
     228
     229    m_databaseAuthorizer->enable();
     230
     231    return result;
     232}
     233
     234bool Database::setVersionInDatabase(const String& version, bool shouldCacheVersion)
     235{
     236    // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
     237    // clause in the CREATE statement (see Database::performOpenAndVerify()).
     238    String query(String("INSERT INTO ") + fullyQualifiedInfoTableName() +  " (key, value) VALUES ('" + versionKey + "', ?);");
     239
     240    m_databaseAuthorizer->disable();
     241
     242    bool result = setTextValueInDatabase(m_sqliteDatabase, query, version);
     243    if (result) {
     244        if (shouldCacheVersion)
     245            setCachedVersion(version);
     246    } else
     247        LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), query.ascii().data());
     248
     249    m_databaseAuthorizer->enable();
     250
     251    return result;
     252}
     253
    154254void Database::scheduleTransaction()
    155255{
    … …  
    348448    while ((result = statement.step()) == SQLITE_ROW) {
    349449        String name = statement.getColumnText(0);
    350         if (name != databaseInfoTableName())
     450        if (name != unqualifiedInfoTableName)
    351451            tableNames.append(name);
    352452    }

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

    r187996 r187998  
    109109    Database(PassRefPtr<DatabaseContext>, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
    110110
     111    bool getVersionFromDatabase(String& version, bool shouldCacheVersion = true);
     112    bool setVersionInDatabase(const String& version, bool shouldCacheVersion = true);
     113
    111114    void scheduleTransaction();
    112115
    … …  
    125128    bool m_hasPendingCreationEvent { false };
    126129
     130    friend class ChangeVersionWrapper;
     131    friend class DatabaseBackendBase;
    127132    friend class DatabaseManager;
    128133    friend class DatabaseServer; // FIXME: remove this when the backend has been split out.

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

    r187996 r187998  
    8282namespace WebCore {
    8383
    84 static const char versionKey[] = "WebKitDatabaseVersionKey";
    8584static const char unqualifiedInfoTableName[] = "__WebKitDatabaseInfoTable__";
    8685
    87 const char* DatabaseBackendBase::databaseInfoTableName()
    88 {
    89     return unqualifiedInfoTableName;
    90 }
    91 
    92 static const char* fullyQualifiedInfoTableName()
    93 {
    94     static const char qualifier[] = "main.";
    95     static char qualifiedName[sizeof(qualifier) + sizeof(unqualifiedInfoTableName) - 1];
    96 
    97     static std::once_flag onceFlag;
    98     std::call_once(onceFlag, []{
    99         strcpy(qualifiedName, qualifier);
    100         strcpy(qualifiedName + sizeof(qualifier) - 1, unqualifiedInfoTableName);
    101     });
    102 
    103     return qualifiedName;
    104 }
    105 
    10686static String formatErrorMessage(const char* message, int sqliteErrorCode, const char* sqliteErrorMessage)
    10787{
    10888    return String::format("%s (%d %s)", message, sqliteErrorCode, sqliteErrorMessage);
    109 }
    110 
    111 static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& query, String& resultString)
    112 {
    113     SQLiteStatement statement(db, query);
    114     int result = statement.prepare();
    115 
    116     if (result != SQLITE_OK) {
    117         LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
    118         return false;
    119     }
    120 
    121     result = statement.step();
    122     if (result == SQLITE_ROW) {
    123         resultString = statement.getColumnText(0);
    124         return true;
    125     }
    126     if (result == SQLITE_DONE) {
    127         resultString = String();
    128         return true;
    129     }
    130 
    131     LOG_ERROR("Error (%i) reading text result from database (%s)", result, query.ascii().data());
    132     return false;
    133 }
    134 
    135 static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, const String& value)
    136 {
    137     SQLiteStatement statement(db, query);
    138     int result = statement.prepare();
    139 
    140     if (result != SQLITE_OK) {
    141         LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
    142         return false;
    143     }
    144 
    145     statement.bindText(1, value);
    146 
    147     result = statement.step();
    148     if (result != SQLITE_DONE) {
    149         LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
    150         return false;
    151     }
    152 
    153     return true;
    15489}
    15590
    … …  
    368303                    return false;
    369304                }
    370             } else if (!getVersionFromDatabase(currentVersion, false)) {
     305            } else if (!m_frontend->getVersionFromDatabase(currentVersion, false)) {
    371306                errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
    372307                transaction.rollback();
    … …  
    379314            } else if (!m_new || shouldSetVersionInNewDatabase) {
    380315                LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
    381                 if (!setVersionInDatabase(m_expectedVersion, false)) {
     316                if (!m_frontend->setVersionInDatabase(m_expectedVersion, false)) {
    382317                    errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
    383318                    transaction.rollback();
    … …  
    455390}
    456391
    457 bool DatabaseBackendBase::getVersionFromDatabase(String& version, bool shouldCacheVersion)
    458 {
    459     String query(String("SELECT value FROM ") + fullyQualifiedInfoTableName() +  " WHERE key = '" + versionKey + "';");
    460 
    461     m_databaseAuthorizer->disable();
    462 
    463     bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, query, version);
    464     if (result) {
    465         if (shouldCacheVersion)
    466             setCachedVersion(version);
    467     } else
    468         LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
    469 
    470     m_databaseAuthorizer->enable();
    471 
    472     return result;
    473 }
    474 
    475 bool DatabaseBackendBase::setVersionInDatabase(const String& version, bool shouldCacheVersion)
    476 {
    477     // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
    478     // clause in the CREATE statement (see Database::performOpenAndVerify()).
    479     String query(String("INSERT INTO ") + fullyQualifiedInfoTableName() +  " (key, value) VALUES ('" + versionKey + "', ?);");
    480 
    481     m_databaseAuthorizer->disable();
    482 
    483     bool result = setTextValueInDatabase(m_sqliteDatabase, query, version);
    484     if (result) {
    485         if (shouldCacheVersion)
    486             setCachedVersion(version);
    487     } else
    488         LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), query.ascii().data());
    489 
    490     m_databaseAuthorizer->enable();
    491 
    492     return result;
    493 }
    494 
    495392void DatabaseBackendBase::setExpectedVersion(const String& version)
    496393{
    … …  
    518415    // Note: In multi-process browsers the cached value may be inaccurate.
    519416    // So we retrieve the value from the database and update the cached value here.
    520     return getVersionFromDatabase(actualVersion, true);
     417    return m_frontend->getVersionFromDatabase(actualVersion, true);
    521418}
    522419

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

    r187996 r187998  
    8282    virtual bool performOpenAndVerify(bool shouldSetVersionInNewDatabase, DatabaseError&, String& errorMessage);
    8383
    84     bool getVersionFromDatabase(String& version, bool shouldCacheVersion = true);
    85     bool setVersionInDatabase(const String& version, bool shouldCacheVersion = true);
    8684    void setExpectedVersion(const String&);
    8785    const String& expectedVersion() const { return m_expectedVersion; }
    … …  
    8987    void setCachedVersion(const String&);
    9088    bool getActualVersionForTransaction(String& version);
    91 
    92     static const char* databaseInfoTableName();
    9389
    9490#if !LOG_DISABLED || !ERROR_DISABLED
Note: See TracChangeset for help on using the changeset viewer.