Use constants of sqlite3 directly for status of SQL result in webdatabase
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 5 Apr 2015 20:44:35 +0000 (20:44 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 5 Apr 2015 20:44:35 +0000 (20:44 +0000)
https://bugs.webkit.org/show_bug.cgi?id=143329

Patch by Gyuyoung Kim <gyuyoung.kim@samsung.com> on 2015-04-05
Reviewed by Darin Adler.

Source/WebCore:

In webdatabase, it has used own constant vairables as well as using sqlite3 constants directly.
It causes to use if~else statement which consumes more cpu cycles compared to switch~case. This
patch makes to use constants of sqlite3. Additionally if~else statment is changed to switch~case
to save cpu cycles.

No new tests, no behavior changes.

* Modules/webdatabase/Database.cpp:
(WebCore::Database::performGetTableNames):
* Modules/webdatabase/DatabaseBackendBase.cpp:
(WebCore::retrieveTextResultFromDatabase):
(WebCore::setTextValueInDatabase):
(WebCore::DatabaseBackendBase::incrementalVacuumIfNeeded):
* Modules/webdatabase/DatabaseTracker.cpp:
(WebCore::DatabaseTracker::hasEntryForOriginNoLock):
(WebCore::DatabaseTracker::hasEntryForDatabase):
(WebCore::DatabaseTracker::fullPathForDatabaseNoLock):
(WebCore::DatabaseTracker::origins):
(WebCore::DatabaseTracker::databaseNamesForOriginNoLock):
(WebCore::DatabaseTracker::detailsForNameAndOrigin):
(WebCore::DatabaseTracker::setDatabaseDetails):
(WebCore::DatabaseTracker::quotaForOriginNoLock):
(WebCore::DatabaseTracker::setQuota):
(WebCore::DatabaseTracker::addDatabase):
(WebCore::DatabaseTracker::deleteOrigin):
(WebCore::DatabaseTracker::deleteDatabase):
(WebCore::DatabaseTracker::removeDeletedOpenedDatabases):
(WebCore::DatabaseTracker::deleteDatabaseFileIfEmpty):
* Modules/webdatabase/SQLStatementBackend.cpp:
(WebCore::SQLStatementBackend::execute):
* Modules/webdatabase/SQLStatementBackend.h:
* Modules/webdatabase/SQLTransactionBackend.cpp:
(WebCore::SQLTransactionBackend::runCurrentStatementAndGetNextState):
Change to use a reference instead of a pointer in arguemnt of execute().
* loader/appcache/ApplicationCacheStorage.cpp:
(WebCore::ApplicationCacheStorage::loadCacheGroup):
(WebCore::ApplicationCacheStorage::loadManifestHostHashes):
(WebCore::ApplicationCacheStorage::cacheGroupForURL):
(WebCore::ApplicationCacheStorage::fallbackCacheGroupForURL):
(WebCore::ApplicationCacheStorage::calculateQuotaForOrigin):
(WebCore::ApplicationCacheStorage::calculateUsageForOrigin):
(WebCore::ApplicationCacheStorage::calculateRemainingSizeForOriginExcludingCache):
(WebCore::ApplicationCacheStorage::storeUpdatedQuotaForOrigin):
(WebCore::ApplicationCacheStorage::verifySchemaVersion):
(WebCore::ApplicationCacheStorage::store):
(WebCore::ApplicationCacheStorage::storeUpdatedType):
(WebCore::ApplicationCacheStorage::ensureOriginRecord):
(WebCore::ApplicationCacheStorage::storeNewestCache):
(WebCore::ApplicationCacheStorage::loadCache):
(WebCore::ApplicationCacheStorage::remove):
(WebCore::ApplicationCacheStorage::getManifestURLs):
(WebCore::ApplicationCacheStorage::cacheGroupSize):
(WebCore::ApplicationCacheStorage::deleteCacheGroupRecord):
(WebCore::ApplicationCacheStorage::checkForMaxSizeReached):
(WebCore::ApplicationCacheStorage::checkForDeletedResources):
(WebCore::ApplicationCacheStorage::flatFileAreaSize):
* loader/icon/IconDatabase.cpp:
(WebCore::IconDatabase::checkIntegrity):
(WebCore::IconDatabase::performURLImport):
(WebCore::IconDatabase::pruneUnretainedIcons):
(WebCore::readySQLiteStatement):
(WebCore::IconDatabase::setIconIDForPageURLInSQLDatabase):
(WebCore::IconDatabase::removePageURLFromSQLDatabase):
(WebCore::IconDatabase::getIconIDForIconURLFromSQLDatabase):
(WebCore::IconDatabase::addIconURLToSQLDatabase):
(WebCore::IconDatabase::getImageDataForIconURLFromSQLDatabase):
(WebCore::IconDatabase::removeIconFromSQLDatabase):
(WebCore::IconDatabase::writeIconSnapshotToSQLDatabase):
* platform/sql/SQLiteDatabase.cpp:
(WebCore::SQLiteDatabase::setMaximumSize):
* platform/sql/SQLiteDatabase.h:
* platform/sql/SQLiteFileSystem.cpp:
(WebCore::SQLiteFileSystem::getFileNameForNewDatabase):
* platform/sql/SQLiteStatement.cpp:
(WebCore::SQLiteStatement::step):
(WebCore::SQLiteStatement::returnIntResults):
(WebCore::SQLiteStatement::returnInt64Results):

Source/WebKit:

In webdatabase, it has used own constants vairables as well as using sqlite3 constants directly.
It causes to use if~else statement which consumes more cpu cycles compared to switch~case. This
patch makes to use constants of sqlite3.

* Storage/StorageAreaSync.cpp:
(WebCore::StorageAreaSync::performImport):
(WebCore::StorageAreaSync::sync):
(WebCore::StorageAreaSync::deleteEmptyDatabase):
* Storage/StorageTracker.cpp:
(WebCore::StorageTracker::syncImportOriginIdentifiers):
(WebCore::StorageTracker::syncSetOriginDetails):
(WebCore::StorageTracker::syncDeleteAllOrigins):
(WebCore::StorageTracker::syncDeleteOrigin):
(WebCore::StorageTracker::databasePathForOrigin):
* WebKit.vcxproj/WebKit/WebKitCommon.props: Add sqlite include path.

Source/WebKit2:

In webdatabase, it has used own constant variables as well as using sqlite3 constants directly.
If sqlite3 constants are changed in the library, we should modify many files as well. Besides
it can cause to use if~else statement which consumes more cpu cycles compared to switch~case.

* DatabaseProcess/IndexedDB/sqlite/SQLiteIDBCursor.cpp:
(WebKit::SQLiteIDBCursor::createSQLiteStatement):
(WebKit::SQLiteIDBCursor::resetAndRebindStatement):
(WebKit::SQLiteIDBCursor::bindArguments):
(WebKit::SQLiteIDBCursor::internalAdvanceOnce):
* DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
(WebKit::createOrMigrateRecordsTableIfNecessary):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::createAndPopulateInitialMetadata):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::extractExistingMetadata):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::changeDatabaseVersion):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::createObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::clearObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::createIndex):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteIndex):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::generateKeyNumber):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::updateKeyGeneratorNumber):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::keyExistsInObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::putRecord):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::uncheckedPutIndexRecord):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteRecord):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRecordFromObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRangeRecordFromObjectStore):
* NetworkProcess/cache/NetworkCacheStatistics.cpp:
(WebKit::NetworkCache::executeSQLStatement):
(WebKit::NetworkCache::Statistics::initialize):
(WebKit::NetworkCache::Statistics::queryWasEverRequested):
(WebKit::NetworkCache::Statistics::addHashesToDatabase):
(WebKit::NetworkCache::Statistics::addStoreDecisionsToDatabase):
* UIProcess/Storage/LocalStorageDatabase.cpp:
(WebKit::LocalStorageDatabase::importItems):
(WebKit::LocalStorageDatabase::updateDatabaseWithChangedItems):
(WebKit::LocalStorageDatabase::databaseIsEmpty):
* UIProcess/Storage/LocalStorageDatabaseTracker.cpp:
(WebKit::LocalStorageDatabaseTracker::deleteAllDatabases):
(WebKit::LocalStorageDatabaseTracker::importOriginIdentifiers):
(WebKit::LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier):
(WebKit::LocalStorageDatabaseTracker::removeDatabaseWithOriginIdentifier):
(WebKit::LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier):
* WebProcess/Cookies/soup/WebKitSoupCookieJarSqlite.cpp:
(webkitSoupCookieJarSqliteLoad):
(webkitSoupCookieJarSqliteInsertCookie):
(webkitSoupCookieJarSqliteDeleteCookie):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@182365 268f45cc-cd09-0410-ab3c-d52691b4dbfc

24 files changed:
Source/WebCore/ChangeLog
Source/WebCore/Modules/webdatabase/Database.cpp
Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp
Source/WebCore/Modules/webdatabase/DatabaseTracker.cpp
Source/WebCore/Modules/webdatabase/SQLStatementBackend.cpp
Source/WebCore/Modules/webdatabase/SQLStatementBackend.h
Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp
Source/WebCore/loader/appcache/ApplicationCacheStorage.cpp
Source/WebCore/loader/icon/IconDatabase.cpp
Source/WebCore/platform/sql/SQLiteDatabase.cpp
Source/WebCore/platform/sql/SQLiteDatabase.h
Source/WebCore/platform/sql/SQLiteFileSystem.cpp
Source/WebCore/platform/sql/SQLiteStatement.cpp
Source/WebKit/ChangeLog
Source/WebKit/Storage/StorageAreaSync.cpp
Source/WebKit/Storage/StorageTracker.cpp
Source/WebKit/WebKit.vcxproj/WebKit/WebKitCommon.props
Source/WebKit2/ChangeLog
Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/SQLiteIDBCursor.cpp
Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp
Source/WebKit2/NetworkProcess/cache/NetworkCacheStatistics.cpp
Source/WebKit2/UIProcess/Storage/LocalStorageDatabase.cpp
Source/WebKit2/UIProcess/Storage/LocalStorageDatabaseTracker.cpp
Source/WebKit2/WebProcess/Cookies/soup/WebKitSoupCookieJarSqlite.cpp

index 6ea1955..eb9367d 100644 (file)
@@ -1,3 +1,88 @@
+2015-04-05  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
+
+        Use constants of sqlite3 directly for status of SQL result in webdatabase
+        https://bugs.webkit.org/show_bug.cgi?id=143329
+
+        Reviewed by Darin Adler.
+
+        In webdatabase, it has used own constant vairables as well as using sqlite3 constants directly.
+        It causes to use if~else statement which consumes more cpu cycles compared to switch~case. This
+        patch makes to use constants of sqlite3. Additionally if~else statment is changed to switch~case
+        to save cpu cycles.
+
+        No new tests, no behavior changes.
+
+        * Modules/webdatabase/Database.cpp:
+        (WebCore::Database::performGetTableNames):
+        * Modules/webdatabase/DatabaseBackendBase.cpp:
+        (WebCore::retrieveTextResultFromDatabase):
+        (WebCore::setTextValueInDatabase):
+        (WebCore::DatabaseBackendBase::incrementalVacuumIfNeeded):
+        * Modules/webdatabase/DatabaseTracker.cpp:
+        (WebCore::DatabaseTracker::hasEntryForOriginNoLock):
+        (WebCore::DatabaseTracker::hasEntryForDatabase):
+        (WebCore::DatabaseTracker::fullPathForDatabaseNoLock):
+        (WebCore::DatabaseTracker::origins):
+        (WebCore::DatabaseTracker::databaseNamesForOriginNoLock):
+        (WebCore::DatabaseTracker::detailsForNameAndOrigin):
+        (WebCore::DatabaseTracker::setDatabaseDetails):
+        (WebCore::DatabaseTracker::quotaForOriginNoLock):
+        (WebCore::DatabaseTracker::setQuota):
+        (WebCore::DatabaseTracker::addDatabase):
+        (WebCore::DatabaseTracker::deleteOrigin):
+        (WebCore::DatabaseTracker::deleteDatabase):
+        (WebCore::DatabaseTracker::removeDeletedOpenedDatabases):
+        (WebCore::DatabaseTracker::deleteDatabaseFileIfEmpty):
+        * Modules/webdatabase/SQLStatementBackend.cpp:
+        (WebCore::SQLStatementBackend::execute):
+        * Modules/webdatabase/SQLStatementBackend.h:
+        * Modules/webdatabase/SQLTransactionBackend.cpp:
+        (WebCore::SQLTransactionBackend::runCurrentStatementAndGetNextState):
+        Change to use a reference instead of a pointer in arguemnt of execute().
+        * loader/appcache/ApplicationCacheStorage.cpp:
+        (WebCore::ApplicationCacheStorage::loadCacheGroup):
+        (WebCore::ApplicationCacheStorage::loadManifestHostHashes):
+        (WebCore::ApplicationCacheStorage::cacheGroupForURL):
+        (WebCore::ApplicationCacheStorage::fallbackCacheGroupForURL):
+        (WebCore::ApplicationCacheStorage::calculateQuotaForOrigin):
+        (WebCore::ApplicationCacheStorage::calculateUsageForOrigin):
+        (WebCore::ApplicationCacheStorage::calculateRemainingSizeForOriginExcludingCache):
+        (WebCore::ApplicationCacheStorage::storeUpdatedQuotaForOrigin):
+        (WebCore::ApplicationCacheStorage::verifySchemaVersion):
+        (WebCore::ApplicationCacheStorage::store):
+        (WebCore::ApplicationCacheStorage::storeUpdatedType):
+        (WebCore::ApplicationCacheStorage::ensureOriginRecord):
+        (WebCore::ApplicationCacheStorage::storeNewestCache):
+        (WebCore::ApplicationCacheStorage::loadCache):
+        (WebCore::ApplicationCacheStorage::remove):
+        (WebCore::ApplicationCacheStorage::getManifestURLs):
+        (WebCore::ApplicationCacheStorage::cacheGroupSize):
+        (WebCore::ApplicationCacheStorage::deleteCacheGroupRecord):
+        (WebCore::ApplicationCacheStorage::checkForMaxSizeReached):
+        (WebCore::ApplicationCacheStorage::checkForDeletedResources):
+        (WebCore::ApplicationCacheStorage::flatFileAreaSize):
+        * loader/icon/IconDatabase.cpp:
+        (WebCore::IconDatabase::checkIntegrity):
+        (WebCore::IconDatabase::performURLImport):
+        (WebCore::IconDatabase::pruneUnretainedIcons):
+        (WebCore::readySQLiteStatement):
+        (WebCore::IconDatabase::setIconIDForPageURLInSQLDatabase):
+        (WebCore::IconDatabase::removePageURLFromSQLDatabase):
+        (WebCore::IconDatabase::getIconIDForIconURLFromSQLDatabase):
+        (WebCore::IconDatabase::addIconURLToSQLDatabase):
+        (WebCore::IconDatabase::getImageDataForIconURLFromSQLDatabase):
+        (WebCore::IconDatabase::removeIconFromSQLDatabase):
+        (WebCore::IconDatabase::writeIconSnapshotToSQLDatabase):
+        * platform/sql/SQLiteDatabase.cpp:
+        (WebCore::SQLiteDatabase::setMaximumSize):
+        * platform/sql/SQLiteDatabase.h:
+        * platform/sql/SQLiteFileSystem.cpp:
+        (WebCore::SQLiteFileSystem::getFileNameForNewDatabase):
+        * platform/sql/SQLiteStatement.cpp:
+        (WebCore::SQLiteStatement::step):
+        (WebCore::SQLiteStatement::returnIntResults):
+        (WebCore::SQLiteStatement::returnInt64Results):
+
 2015-04-05  Simon Fraser  <simon.fraser@apple.com>
 
         Remove "go ahead and" from comments
index 9bbca0f..a265c74 100644 (file)
@@ -314,7 +314,7 @@ Vector<String> Database::performGetTableNames()
     disableAuthorizer();
 
     SQLiteStatement statement(sqliteDatabase(), "SELECT name FROM sqlite_master WHERE type='table';");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to retrieve list of tables for database %s", databaseDebugName().ascii().data());
         enableAuthorizer();
         return Vector<String>();
@@ -322,7 +322,7 @@ Vector<String> Database::performGetTableNames()
 
     Vector<String> tableNames;
     int result;
-    while ((result = statement.step()) == SQLResultRow) {
+    while ((result = statement.step()) == SQLITE_ROW) {
         String name = statement.getColumnText(0);
         if (name != databaseInfoTableName())
             tableNames.append(name);
@@ -330,7 +330,7 @@ Vector<String> Database::performGetTableNames()
 
     enableAuthorizer();
 
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("Error getting tables for database %s", databaseDebugName().ascii().data());
         return Vector<String>();
     }
index e6d7513..9d63f09 100644 (file)
@@ -94,17 +94,17 @@ static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& que
     SQLiteStatement statement(db, query);
     int result = statement.prepare();
 
-    if (result != SQLResultOk) {
+    if (result != SQLITE_OK) {
         LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
         return false;
     }
 
     result = statement.step();
-    if (result == SQLResultRow) {
+    if (result == SQLITE_ROW) {
         resultString = statement.getColumnText(0);
         return true;
     }
-    if (result == SQLResultDone) {
+    if (result == SQLITE_DONE) {
         resultString = String();
         return true;
     }
@@ -118,7 +118,7 @@ static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, cons
     SQLiteStatement statement(db, query);
     int result = statement.prepare();
 
-    if (result != SQLResultOk) {
+    if (result != SQLITE_OK) {
         LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
         return false;
     }
@@ -126,7 +126,7 @@ static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, cons
     statement.bindText(1, value);
 
     result = statement.step();
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
         return false;
     }
@@ -568,7 +568,7 @@ void DatabaseBackendBase::incrementalVacuumIfNeeded()
     int64_t totalSize = m_sqliteDatabase.totalSize();
     if (totalSize <= 10 * freeSpaceSize) {
         int result = m_sqliteDatabase.runIncrementalVacuumCommand();
-        if (result != SQLResultOk)
+        if (result != SQLITE_OK)
             m_frontend->logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
     }
 }
index c95b77e..a3f5826 100644 (file)
@@ -244,14 +244,14 @@ bool DatabaseTracker::hasEntryForOriginNoLock(SecurityOrigin* origin)
         return false;
 
     SQLiteStatement statement(m_database, "SELECT origin FROM Origins where origin=?;");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare statement.");
         return false;
     }
 
     statement.bindText(1, origin->databaseIdentifier());
 
-    return statement.step() == SQLResultRow;
+    return statement.step() == SQLITE_ROW;
 }
 
 bool DatabaseTracker::hasEntryForOrigin(SecurityOrigin* origin)
@@ -272,13 +272,13 @@ bool DatabaseTracker::hasEntryForDatabase(SecurityOrigin* origin, const String&
     // We've got a tracker database. Set up a query to ask for the db of interest:
     SQLiteStatement statement(m_database, "SELECT guid FROM Databases WHERE origin=? AND name=?;");
 
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindText(1, origin->databaseIdentifier());
     statement.bindText(2, databaseIdentifier);
 
-    return statement.step() == SQLResultRow;
+    return statement.step() == SQLITE_ROW;
 }
 
 unsigned long long DatabaseTracker::getMaxSizeForDatabase(const Database* database)
@@ -356,7 +356,7 @@ String DatabaseTracker::fullPathForDatabaseNoLock(SecurityOrigin* origin, const
         return String();
     SQLiteStatement statement(m_database, "SELECT path FROM Databases WHERE origin=? AND name=?;");
 
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return String();
 
     statement.bindText(1, originIdentifier);
@@ -364,12 +364,12 @@ String DatabaseTracker::fullPathForDatabaseNoLock(SecurityOrigin* origin, const
 
     int result = statement.step();
 
-    if (result == SQLResultRow)
+    if (result == SQLITE_ROW)
         return SQLiteFileSystem::appendDatabaseFileNameToPath(originPath, statement.getColumnText(0));
     if (!createIfNotExists)
         return String();
 
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("Failed to retrieve filename from Database Tracker for origin %s, name %s", originIdentifier.ascii().data(), name.ascii().data());
         return String();
     }
@@ -401,19 +401,19 @@ void DatabaseTracker::origins(Vector<RefPtr<SecurityOrigin>>& originsResult)
         return;
 
     SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare statement.");
         return;
     }
 
     int result;
-    while ((result = statement.step()) == SQLResultRow) {
+    while ((result = statement.step()) == SQLITE_ROW) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromDatabaseIdentifier(statement.getColumnText(0));
         originsResult.append(origin->isolatedCopy());
     }
     originsResult.shrinkToFit();
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Failed to read in all origins from the database.");
 }
 
@@ -426,16 +426,16 @@ bool DatabaseTracker::databaseNamesForOriginNoLock(SecurityOrigin* origin, Vecto
 
     SQLiteStatement statement(m_database, "SELECT name FROM Databases where origin=?;");
 
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindText(1, origin->databaseIdentifier());
 
     int result;
-    while ((result = statement.step()) == SQLResultRow)
+    while ((result = statement.step()) == SQLITE_ROW)
         resultVector.append(statement.getColumnText(0));
 
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("Failed to retrieve all database names for origin %s", origin->databaseIdentifier().ascii().data());
         return false;
     }
@@ -470,17 +470,17 @@ DatabaseDetails DatabaseTracker::detailsForNameAndOrigin(const String& name, Sec
         if (!m_database.isOpen())
             return DatabaseDetails();
         SQLiteStatement statement(m_database, "SELECT displayName, estimatedSize FROM Databases WHERE origin=? AND name=?");
-        if (statement.prepare() != SQLResultOk)
+        if (statement.prepare() != SQLITE_OK)
             return DatabaseDetails();
 
         statement.bindText(1, originIdentifier);
         statement.bindText(2, name);
 
         int result = statement.step();
-        if (result == SQLResultDone)
+        if (result == SQLITE_DONE)
             return DatabaseDetails();
 
-        if (result != SQLResultRow) {
+        if (result != SQLITE_ROW) {
             LOG_ERROR("Error retrieving details for database %s in origin %s from tracker database", name.ascii().data(), originIdentifier.ascii().data());
             return DatabaseDetails();
         }
@@ -505,19 +505,19 @@ void DatabaseTracker::setDatabaseDetails(SecurityOrigin* origin, const String& n
     if (!m_database.isOpen())
         return;
     SQLiteStatement statement(m_database, "SELECT guid FROM Databases WHERE origin=? AND name=?");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return;
 
     statement.bindText(1, originIdentifier);
     statement.bindText(2, name);
 
     int result = statement.step();
-    if (result == SQLResultRow)
+    if (result == SQLITE_ROW)
         guid = statement.getColumnInt64(0);
     statement.finalize();
 
     if (guid == 0) {
-        if (result != SQLResultDone)
+        if (result != SQLITE_DONE)
             LOG_ERROR("Error to determing existence of database %s in origin %s in tracker database", name.ascii().data(), originIdentifier.ascii().data());
         else {
             // This case should never occur - we should never be setting database details for a database that doesn't already exist in the tracker
@@ -530,14 +530,14 @@ void DatabaseTracker::setDatabaseDetails(SecurityOrigin* origin, const String& n
     }
 
     SQLiteStatement updateStatement(m_database, "UPDATE Databases SET displayName=?, estimatedSize=? WHERE guid=?");
-    if (updateStatement.prepare() != SQLResultOk)
+    if (updateStatement.prepare() != SQLITE_OK)
         return;
 
     updateStatement.bindText(1, displayName);
     updateStatement.bindInt64(2, estimatedSize);
     updateStatement.bindInt64(3, guid);
 
-    if (updateStatement.step() != SQLResultDone) {
+    if (updateStatement.step() != SQLITE_DONE) {
         LOG_ERROR("Failed to update details for database %s in origin %s", name.ascii().data(), originIdentifier.ascii().data());
         return;
     }
@@ -715,13 +715,13 @@ unsigned long long DatabaseTracker::quotaForOriginNoLock(SecurityOrigin* origin)
         return quota;
 
     SQLiteStatement statement(m_database, "SELECT quota FROM Origins where origin=?;");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare statement.");
         return quota;
     }
     statement.bindText(1, origin->databaseIdentifier());
 
-    if (statement.step() == SQLResultRow)
+    if (statement.step() == SQLITE_ROW)
         quota = statement.getColumnInt64(0);
 
     return quota;
@@ -751,13 +751,13 @@ void DatabaseTracker::setQuota(SecurityOrigin* origin, unsigned long long quota)
     bool originEntryExists = hasEntryForOriginNoLock(origin);
     if (!originEntryExists) {
         SQLiteStatement statement(m_database, "INSERT INTO Origins VALUES (?, ?)");
-        if (statement.prepare() != SQLResultOk) {
+        if (statement.prepare() != SQLITE_OK) {
             LOG_ERROR("Unable to establish origin %s in the tracker", origin->databaseIdentifier().ascii().data());
         } else {
             statement.bindText(1, origin->databaseIdentifier());
             statement.bindInt64(2, quota);
 
-            if (statement.step() != SQLResultDone)
+            if (statement.step() != SQLITE_DONE)
                 LOG_ERROR("Unable to establish origin %s in the tracker", origin->databaseIdentifier().ascii().data());
 #if PLATFORM(IOS)
             else
@@ -766,7 +766,7 @@ void DatabaseTracker::setQuota(SecurityOrigin* origin, unsigned long long quota)
         }
     } else {
         SQLiteStatement statement(m_database, "UPDATE Origins SET quota=? WHERE origin=?");
-        bool error = statement.prepare() != SQLResultOk;
+        bool error = statement.prepare() != SQLITE_OK;
         if (!error) {
             statement.bindInt64(1, quota);
             statement.bindText(2, origin->databaseIdentifier());
@@ -802,7 +802,7 @@ bool DatabaseTracker::addDatabase(SecurityOrigin* origin, const String& name, co
 
     SQLiteStatement statement(m_database, "INSERT INTO Databases (origin, name, path) VALUES (?, ?, ?);");
 
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindText(1, origin->databaseIdentifier());
@@ -891,7 +891,7 @@ bool DatabaseTracker::deleteOrigin(SecurityOrigin* origin)
         doneDeletingOrigin(origin);
 
         SQLiteStatement statement(m_database, "DELETE FROM Databases WHERE origin=?");
-        if (statement.prepare() != SQLResultOk) {
+        if (statement.prepare() != SQLITE_OK) {
             LOG_ERROR("Unable to prepare deletion of databases from origin %s from tracker", origin->databaseIdentifier().ascii().data());
             return false;
         }
@@ -904,7 +904,7 @@ bool DatabaseTracker::deleteOrigin(SecurityOrigin* origin)
         }
 
         SQLiteStatement originStatement(m_database, "DELETE FROM Origins WHERE origin=?");
-        if (originStatement.prepare() != SQLResultOk) {
+        if (originStatement.prepare() != SQLITE_OK) {
             LOG_ERROR("Unable to prepare deletion of origin %s from tracker", origin->databaseIdentifier().ascii().data());
             return false;
         }
@@ -924,9 +924,9 @@ bool DatabaseTracker::deleteOrigin(SecurityOrigin* origin)
         openTrackerDatabase(DontCreateIfDoesNotExist);
         if (m_database.isOpen()) {
             SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
-            if (statement.prepare() != SQLResultOk)
+            if (statement.prepare() != SQLITE_OK)
                 LOG_ERROR("Failed to prepare statement.");
-            else if (statement.step() == SQLResultRow)
+            else if (statement.step() == SQLITE_ROW)
                 isEmpty = false;
         }
 
@@ -1090,7 +1090,7 @@ bool DatabaseTracker::deleteDatabase(SecurityOrigin* origin, const String& name)
     MutexLocker lockDatabase(m_databaseGuard);
 
     SQLiteStatement statement(m_database, "DELETE FROM Databases WHERE origin=? AND name=?");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to prepare deletion of database %s from origin %s from tracker", name.ascii().data(), origin->databaseIdentifier().ascii().data());
         doneDeletingDatabase(origin, name);
         return false;
@@ -1213,10 +1213,10 @@ void DatabaseTracker::removeDeletedOpenedDatabases()
                     String databaseName = dbNameMapIt->key;
                     String databaseFileName;
                     SQLiteStatement statement(m_database, "SELECT path FROM Databases WHERE origin=? AND name=?;");
-                    if (statement.prepare() == SQLResultOk) {
+                    if (statement.prepare() == SQLITE_OK) {
                         statement.bindText(1, origin->databaseIdentifier());
                         statement.bindText(2, databaseName);
-                        if (statement.step() == SQLResultRow)
+                        if (statement.step() == SQLITE_ROW)
                             databaseFileName = statement.getColumnText(0);
                         statement.finalize();
                     }
@@ -1284,20 +1284,20 @@ bool DatabaseTracker::deleteDatabaseFileIfEmpty(const String& path)
     // Specify that we want the exclusive locking mode, so after the next read,
     // we'll be holding the lock to this database file.
     SQLiteStatement lockStatement(database, "PRAGMA locking_mode=EXCLUSIVE;");
-    if (lockStatement.prepare() != SQLResultOk)
+    if (lockStatement.prepare() != SQLITE_OK)
         return false;
     int result = lockStatement.step();
-    if (result != SQLResultRow && result != SQLResultDone)
+    if (result != SQLITE_ROW && result != SQLITE_DONE)
         return false;
     lockStatement.finalize();
 
     // Every sqlite database has a sqlite_master table that contains the schema for the database.
     // http://www.sqlite.org/faq.html#q7
     SQLiteStatement readStatement(database, "SELECT * FROM sqlite_master LIMIT 1;");    
-    if (readStatement.prepare() != SQLResultOk)
+    if (readStatement.prepare() != SQLITE_OK)
         return false;
     // We shouldn't expect any result.
-    if (readStatement.step() != SQLResultDone)
+    if (readStatement.step() != SQLITE_DONE)
         return false;
     readStatement.finalize();
     
index fb001df..067dcba 100644 (file)
@@ -112,7 +112,7 @@ PassRefPtr<SQLResultSet> SQLStatementBackend::sqlResultSet() const
     return m_resultSet;
 }
 
-bool SQLStatementBackend::execute(DatabaseBackend* db)
+bool SQLStatementBackend::execute(DatabaseBackend& db)
 {
     ASSERT(!m_resultSet);
 
@@ -124,19 +124,19 @@ bool SQLStatementBackend::execute(DatabaseBackend* db)
     if (m_error)
         return false;
 
-    db->setAuthorizerPermissions(m_permissions);
+    db.setAuthorizerPermissions(m_permissions);
 
-    SQLiteDatabase* database = &db->sqliteDatabase();
+    SQLiteDatabase& database = db.sqliteDatabase();
 
-    SQLiteStatement statement(*database, m_statement);
+    SQLiteStatement statement(database, m_statement);
     int result = statement.prepare();
 
-    if (result != SQLResultOk) {
-        LOG(StorageAPI, "Unable to verify correctness of statement %s - error %i (%s)", m_statement.ascii().data(), result, database->lastErrorMsg());
-        if (result == SQLResultInterrupt)
+    if (result != SQLITE_OK) {
+        LOG(StorageAPI, "Unable to verify correctness of statement %s - error %i (%s)", m_statement.ascii().data(), result, database.lastErrorMsg());
+        if (result == SQLITE_INTERRUPT)
             m_error = SQLError::create(SQLError::DATABASE_ERR, "could not prepare statement", result, "interrupted");
         else
-            m_error = SQLError::create(SQLError::SYNTAX_ERR, "could not prepare statement", result, database->lastErrorMsg());
+            m_error = SQLError::create(SQLError::SYNTAX_ERR, "could not prepare statement", result, database.lastErrorMsg());
         return false;
     }
 
@@ -144,20 +144,20 @@ bool SQLStatementBackend::execute(DatabaseBackend* db)
     // If this is the case, they might be trying to do something fishy or malicious
     if (statement.bindParameterCount() != m_arguments.size()) {
         LOG(StorageAPI, "Bind parameter count doesn't match number of question marks");
-        m_error = SQLError::create(db->isInterrupted() ? SQLError::DATABASE_ERR : SQLError::SYNTAX_ERR, "number of '?'s in statement string does not match argument count");
+        m_error = SQLError::create(db.isInterrupted() ? SQLError::DATABASE_ERR : SQLError::SYNTAX_ERR, "number of '?'s in statement string does not match argument count");
         return false;
     }
 
     for (unsigned i = 0; i < m_arguments.size(); ++i) {
         result = statement.bindValue(i + 1, m_arguments[i]);
-        if (result == SQLResultFull) {
+        if (result == SQLITE_FULL) {
             setFailureDueToQuota();
             return false;
         }
 
-        if (result != SQLResultOk) {
+        if (result != SQLITE_OK) {
             LOG(StorageAPI, "Failed to bind value index %i to statement for query '%s'", i + 1, m_statement.ascii().data());
-            m_error = SQLError::create(SQLError::DATABASE_ERR, "could not bind value", result, database->lastErrorMsg());
+            m_error = SQLError::create(SQLError::DATABASE_ERR, "could not bind value", result, database.lastErrorMsg());
             return false;
         }
     }
@@ -166,7 +166,8 @@ bool SQLStatementBackend::execute(DatabaseBackend* db)
 
     // Step so we can fetch the column names.
     result = statement.step();
-    if (result == SQLResultRow) {
+    switch (result) {
+    case SQLITE_ROW: {
         int columnCount = statement.columnCount();
         SQLResultSetRowList* rows = resultSet->rows();
 
@@ -178,32 +179,36 @@ bool SQLStatementBackend::execute(DatabaseBackend* db)
                 rows->addResult(statement.getColumnValue(i));
 
             result = statement.step();
-        } while (result == SQLResultRow);
+        } while (result == SQLITE_ROW);
 
-        if (result != SQLResultDone) {
-            m_error = SQLError::create(SQLError::DATABASE_ERR, "could not iterate results", result, database->lastErrorMsg());
+        if (result != SQLITE_DONE) {
+            m_error = SQLError::create(SQLError::DATABASE_ERR, "could not iterate results", result, database.lastErrorMsg());
             return false;
         }
-    } else if (result == SQLResultDone) {
+        break;
+    }
+    case SQLITE_DONE: {
         // Didn't find anything, or was an insert
-        if (db->lastActionWasInsert())
-            resultSet->setInsertId(database->lastInsertRowID());
-    } else if (result == SQLResultFull) {
+        if (db.lastActionWasInsert())
+            resultSet->setInsertId(database.lastInsertRowID());
+        break;
+    }
+    case SQLITE_FULL:
         // Return the Quota error - the delegate will be asked for more space and this statement might be re-run
         setFailureDueToQuota();
         return false;
-    } else if (result == SQLResultConstraint) {
-        m_error = SQLError::create(SQLError::CONSTRAINT_ERR, "could not execute statement due to a constaint failure", result, database->lastErrorMsg());
+    case SQLITE_CONSTRAINT:
+        m_error = SQLError::create(SQLError::CONSTRAINT_ERR, "could not execute statement due to a constaint failure", result, database.lastErrorMsg());
         return false;
-    } else {
-        m_error = SQLError::create(SQLError::DATABASE_ERR, "could not execute statement", result, database->lastErrorMsg());
+    default:
+        m_error = SQLError::create(SQLError::DATABASE_ERR, "could not execute statement", result, database.lastErrorMsg());
         return false;
     }
 
     // FIXME: If the spec allows triggers, and we want to be "accurate" in a different way, we'd use
     // sqlite3_total_changes() here instead of sqlite3_changed, because that includes rows modified from within a trigger
     // For now, this seems sufficient
-    resultSet->setRowsAffected(database->lastChanges());
+    resultSet->setRowsAffected(database.lastChanges());
 
     m_resultSet = resultSet;
     return true;
index d01510d..20d4317 100644 (file)
@@ -47,7 +47,7 @@ public:
         const String& sqlStatement, const Vector<SQLValue>& arguments, int permissions);
     virtual ~SQLStatementBackend();
 
-    bool execute(DatabaseBackend*);
+    bool execute(DatabaseBackend&);
     bool lastExecutionFailedDueToQuota() const;
 
     bool hasStatementCallback() const { return m_hasCallback; }
index d6e2abb..2d6e77c 100644 (file)
@@ -683,7 +683,7 @@ SQLTransactionState SQLTransactionBackend::runCurrentStatementAndGetNextState()
     if (m_hasVersionMismatch)
         m_currentStatementBackend->setVersionMismatchedError();
 
-    if (m_currentStatementBackend->execute(m_database.get())) {
+    if (m_currentStatementBackend->execute(*m_database)) {
         if (m_database->lastActionChangedDatabase()) {
             // Flag this transaction as having changed the database for later delegate notification
             m_modifiedDatabase = true;
index 9ee7fce..0fe60d2 100644 (file)
@@ -108,16 +108,16 @@ ApplicationCacheGroup* ApplicationCacheStorage::loadCacheGroup(const URL& manife
         return 0;
 
     SQLiteStatement statement(m_database, "SELECT id, manifestURL, newestCache FROM CacheGroups WHERE newestCache IS NOT NULL AND manifestURL=?");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return 0;
     
     statement.bindText(1, manifestURL);
    
     int result = statement.step();
-    if (result == SQLResultDone)
+    if (result == SQLITE_DONE)
         return 0;
     
-    if (result != SQLResultRow) {
+    if (result != SQLITE_ROW) {
         LOG_ERROR("Could not load cache group, error \"%s\"", m_database.lastErrorMsg());
         return 0;
     }
@@ -185,10 +185,10 @@ void ApplicationCacheStorage::loadManifestHostHashes()
 
     // Fetch the host hashes.
     SQLiteStatement statement(m_database, "SELECT manifestHostHash FROM CacheGroups");    
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return;
     
-    while (statement.step() == SQLResultRow)
+    while (statement.step() == SQLITE_ROW)
         m_cacheHostSet.add(static_cast<unsigned>(statement.getColumnInt64(0)));
 }    
 
@@ -226,11 +226,11 @@ ApplicationCacheGroup* ApplicationCacheStorage::cacheGroupForURL(const URL& url)
 
     // Check the database. Look for all cache groups with a newest cache.
     SQLiteStatement statement(m_database, "SELECT id, manifestURL, newestCache FROM CacheGroups WHERE newestCache IS NOT NULL");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return 0;
     
     int result;
-    while ((result = statement.step()) == SQLResultRow) {
+    while ((result = statement.step()) == SQLITE_ROW) {
         URL manifestURL = URL(ParsedURLString, statement.getColumnText(1));
 
         if (m_cachesInMemory.contains(manifestURL))
@@ -262,7 +262,7 @@ ApplicationCacheGroup* ApplicationCacheStorage::cacheGroupForURL(const URL& url)
         return group;
     }
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Could not load cache group, error \"%s\"", m_database.lastErrorMsg());
     
     return 0;
@@ -295,11 +295,11 @@ ApplicationCacheGroup* ApplicationCacheStorage::fallbackCacheGroupForURL(const U
         
     // Check the database. Look for all cache groups with a newest cache.
     SQLiteStatement statement(m_database, "SELECT id, manifestURL, newestCache FROM CacheGroups WHERE newestCache IS NOT NULL");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return 0;
     
     int result;
-    while ((result = statement.step()) == SQLResultRow) {
+    while ((result = statement.step()) == SQLITE_ROW) {
         URL manifestURL = URL(ParsedURLString, statement.getColumnText(1));
 
         if (m_cachesInMemory.contains(manifestURL))
@@ -332,7 +332,7 @@ ApplicationCacheGroup* ApplicationCacheStorage::fallbackCacheGroupForURL(const U
         return group;
     }
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Could not load cache group, error \"%s\"", m_database.lastErrorMsg());
     
     return 0;
@@ -446,14 +446,14 @@ bool ApplicationCacheStorage::calculateQuotaForOrigin(const SecurityOrigin* orig
     // Using the count to determine if a record existed or not is a safe way to determine
     // if a quota of 0 is real, from the record, or from null.
     SQLiteStatement statement(m_database, "SELECT COUNT(quota), quota FROM Origins WHERE origin=?");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindText(1, origin->databaseIdentifier());
     int result = statement.step();
 
     // Return the quota, or if it was null the default.
-    if (result == SQLResultRow) {
+    if (result == SQLITE_ROW) {
         bool wasNoRecord = statement.getColumnInt64(0) == 0;
         quota = wasNoRecord ? m_defaultOriginQuota : statement.getColumnInt64(1);
         return true;
@@ -474,13 +474,13 @@ bool ApplicationCacheStorage::calculateUsageForOrigin(const SecurityOrigin* orig
                                           " INNER JOIN Origins ON CacheGroups.origin = Origins.origin"
                                           " INNER JOIN Caches ON CacheGroups.id = Caches.cacheGroup"
                                           " WHERE Origins.origin=?");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindText(1, origin->databaseIdentifier());
     int result = statement.step();
 
-    if (result == SQLResultRow) {
+    if (result == SQLITE_ROW) {
         usage = statement.getColumnInt64(0);
         return true;
     }
@@ -517,7 +517,7 @@ bool ApplicationCacheStorage::calculateRemainingSizeForOriginExcludingCache(cons
     }
 
     SQLiteStatement statement(m_database, query);
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindText(1, origin->databaseIdentifier());
@@ -527,7 +527,7 @@ bool ApplicationCacheStorage::calculateRemainingSizeForOriginExcludingCache(cons
 
     // If the count was 0 that then we have to query the origin table directly
     // for its quota. Otherwise we can use the calculated value.
-    if (result == SQLResultRow) {
+    if (result == SQLITE_ROW) {
         int64_t numberOfCaches = statement.getColumnInt64(0);
         if (numberOfCaches == 0)
             calculateQuotaForOrigin(origin, remainingSize);
@@ -552,7 +552,7 @@ bool ApplicationCacheStorage::storeUpdatedQuotaForOrigin(const SecurityOrigin* o
         return false;
 
     SQLiteStatement updateStatement(m_database, "UPDATE Origins SET quota=? WHERE origin=?");
-    if (updateStatement.prepare() != SQLResultOk)
+    if (updateStatement.prepare() != SQLITE_OK)
         return false;
 
     updateStatement.bindInt64(1, quota);
@@ -600,7 +600,7 @@ void ApplicationCacheStorage::verifySchemaVersion()
     ASSERT_UNUSED(unusedNumBytes, static_cast<int>(sizeof(userVersionSQL)) >= unusedNumBytes);
 
     SQLiteStatement statement(m_database, userVersionSQL);
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return;
     
     executeStatement(statement);
@@ -700,7 +700,7 @@ bool ApplicationCacheStorage::store(ApplicationCacheGroup* group, GroupStorageID
     deleteCacheGroupRecord(group->manifestURL());
 
     SQLiteStatement statement(m_database, "INSERT INTO CacheGroups (manifestHostHash, manifestURL, origin) VALUES (?, ?, ?)");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindInt64(1, urlHostHash(group->manifestURL()));
@@ -728,7 +728,7 @@ bool ApplicationCacheStorage::store(ApplicationCache* cache, ResourceStorageIDJo
     ASSERT(storageIDJournal);
     
     SQLiteStatement statement(m_database, "INSERT INTO Caches (cacheGroup, size) VALUES (?, ?)");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindInt64(1, cache->group()->storageID());
@@ -813,7 +813,7 @@ bool ApplicationCacheStorage::store(ApplicationCacheResource* resource, unsigned
 
     // First, insert the data
     SQLiteStatement dataStatement(m_database, "INSERT INTO CacheResourceData (data, path) VALUES (?, ?)");
-    if (dataStatement.prepare() != SQLResultOk)
+    if (dataStatement.prepare() != SQLITE_OK)
         return false;
     
 
@@ -875,7 +875,7 @@ bool ApplicationCacheStorage::store(ApplicationCacheResource* resource, unsigned
     String headers = stringBuilder.toString();
     
     SQLiteStatement resourceStatement(m_database, "INSERT INTO CacheResources (url, statusCode, responseURL, headers, data, mimeType, textEncodingName) VALUES (?, ?, ?, ?, ?, ?, ?)");
-    if (resourceStatement.prepare() != SQLResultOk)
+    if (resourceStatement.prepare() != SQLITE_OK)
         return false;
     
     // The same ApplicationCacheResource are used in ApplicationCacheResource::size()
@@ -896,7 +896,7 @@ bool ApplicationCacheStorage::store(ApplicationCacheResource* resource, unsigned
     
     // Finally, insert the cache entry
     SQLiteStatement entryStatement(m_database, "INSERT INTO CacheEntries (cache, type, resource) VALUES (?, ?, ?)");
-    if (entryStatement.prepare() != SQLResultOk)
+    if (entryStatement.prepare() != SQLITE_OK)
         return false;
     
     entryStatement.bindInt64(1, cacheStorageID);
@@ -925,7 +925,7 @@ bool ApplicationCacheStorage::storeUpdatedType(ApplicationCacheResource* resourc
 
     // First, insert the data
     SQLiteStatement entryStatement(m_database, "UPDATE CacheEntries SET type=? WHERE resource=?");
-    if (entryStatement.prepare() != SQLResultOk)
+    if (entryStatement.prepare() != SQLITE_OK)
         return false;
 
     entryStatement.bindInt64(1, resource->type());
@@ -958,7 +958,7 @@ bool ApplicationCacheStorage::store(ApplicationCacheResource* resource, Applicat
 
     // A resource was added to the cache. Update the total data size for the cache.
     SQLiteStatement sizeUpdateStatement(m_database, "UPDATE Caches SET size=size+? WHERE id=?");
-    if (sizeUpdateStatement.prepare() != SQLResultOk)
+    if (sizeUpdateStatement.prepare() != SQLITE_OK)
         return false;
 
     sizeUpdateStatement.bindInt64(1, resource->estimatedSizeInStorage());
@@ -975,7 +975,7 @@ bool ApplicationCacheStorage::ensureOriginRecord(const SecurityOrigin* origin)
 {
     ASSERT(SQLiteDatabaseTracker::hasTransactionInProgress());
     SQLiteStatement insertOriginStatement(m_database, "INSERT INTO Origins (origin, quota) VALUES (?, ?)");
-    if (insertOriginStatement.prepare() != SQLResultOk)
+    if (insertOriginStatement.prepare() != SQLITE_OK)
         return false;
 
     insertOriginStatement.bindText(1, origin->databaseIdentifier());
@@ -1058,7 +1058,7 @@ bool ApplicationCacheStorage::storeNewestCache(ApplicationCacheGroup* group, App
     // Update the newest cache in the group.
     
     SQLiteStatement statement(m_database, "UPDATE CacheGroups SET newestCache=? WHERE id=?");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         failureReason = DiskOrOperationFailure;
         return false;
     }
@@ -1125,7 +1125,7 @@ PassRefPtr<ApplicationCache> ApplicationCacheStorage::loadCache(unsigned storage
     SQLiteStatement cacheStatement(m_database,
                                    "SELECT url, statusCode, type, mimeType, textEncodingName, headers, CacheResourceData.data, CacheResourceData.path FROM CacheEntries INNER JOIN CacheResources ON CacheEntries.resource=CacheResources.id "
                                    "INNER JOIN CacheResourceData ON CacheResourceData.id=CacheResources.data WHERE CacheEntries.cache=?");
-    if (cacheStatement.prepare() != SQLResultOk) {
+    if (cacheStatement.prepare() != SQLITE_OK) {
         LOG_ERROR("Could not prepare cache statement, error \"%s\"", m_database.lastErrorMsg());
         return 0;
     }
@@ -1137,7 +1137,7 @@ PassRefPtr<ApplicationCache> ApplicationCacheStorage::loadCache(unsigned storage
     String flatFileDirectory = pathByAppendingComponent(m_cacheDirectory, flatFileSubdirectory);
 
     int result;
-    while ((result = cacheStatement.step()) == SQLResultRow) {
+    while ((result = cacheStatement.step()) == SQLITE_ROW) {
         URL url(ParsedURLString, cacheStatement.getColumnText(0));
         
         int httpStatusCode = cacheStatement.getColumnInt(1);
@@ -1175,7 +1175,7 @@ PassRefPtr<ApplicationCache> ApplicationCacheStorage::loadCache(unsigned storage
             cache->addResource(resource.release());
     }
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Could not load cache resources, error \"%s\"", m_database.lastErrorMsg());
 
     if (!cache->manifestResource()) {
@@ -1185,45 +1185,45 @@ PassRefPtr<ApplicationCache> ApplicationCacheStorage::loadCache(unsigned storage
 
     // Load the online whitelist
     SQLiteStatement whitelistStatement(m_database, "SELECT url FROM CacheWhitelistURLs WHERE cache=?");
-    if (whitelistStatement.prepare() != SQLResultOk)
+    if (whitelistStatement.prepare() != SQLITE_OK)
         return 0;
     whitelistStatement.bindInt64(1, storageID);
     
     Vector<URL> whitelist;
-    while ((result = whitelistStatement.step()) == SQLResultRow
+    while ((result = whitelistStatement.step()) == SQLITE_ROW
         whitelist.append(URL(ParsedURLString, whitelistStatement.getColumnText(0)));
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Could not load cache online whitelist, error \"%s\"", m_database.lastErrorMsg());
 
     cache->setOnlineWhitelist(whitelist);
 
     // Load online whitelist wildcard flag.
     SQLiteStatement whitelistWildcardStatement(m_database, "SELECT wildcard FROM CacheAllowsAllNetworkRequests WHERE cache=?");
-    if (whitelistWildcardStatement.prepare() != SQLResultOk)
+    if (whitelistWildcardStatement.prepare() != SQLITE_OK)
         return 0;
     whitelistWildcardStatement.bindInt64(1, storageID);
     
     result = whitelistWildcardStatement.step();
-    if (result != SQLResultRow)
+    if (result != SQLITE_ROW)
         LOG_ERROR("Could not load cache online whitelist wildcard flag, error \"%s\"", m_database.lastErrorMsg());
 
     cache->setAllowsAllNetworkRequests(whitelistWildcardStatement.getColumnInt64(0));
 
-    if (whitelistWildcardStatement.step() != SQLResultDone)
+    if (whitelistWildcardStatement.step() != SQLITE_DONE)
         LOG_ERROR("Too many rows for online whitelist wildcard flag");
 
     // Load fallback URLs.
     SQLiteStatement fallbackStatement(m_database, "SELECT namespace, fallbackURL FROM FallbackURLs WHERE cache=?");
-    if (fallbackStatement.prepare() != SQLResultOk)
+    if (fallbackStatement.prepare() != SQLITE_OK)
         return 0;
     fallbackStatement.bindInt64(1, storageID);
     
     FallbackURLVector fallbackURLs;
-    while ((result = fallbackStatement.step()) == SQLResultRow
+    while ((result = fallbackStatement.step()) == SQLITE_ROW
         fallbackURLs.append(std::make_pair(URL(ParsedURLString, fallbackStatement.getColumnText(0)), URL(ParsedURLString, fallbackStatement.getColumnText(1))));
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Could not load fallback URLs, error \"%s\"", m_database.lastErrorMsg());
 
     cache->setFallbackURLs(fallbackURLs);
@@ -1249,7 +1249,7 @@ void ApplicationCacheStorage::remove(ApplicationCache* cache)
 
     // All associated data will be deleted by database triggers.
     SQLiteStatement statement(m_database, "DELETE FROM Caches WHERE id=?");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return;
     
     statement.bindInt64(1, cache->storageID());
@@ -1260,7 +1260,7 @@ void ApplicationCacheStorage::remove(ApplicationCache* cache)
     if (cache->group()->newestCache() == cache) {
         // Currently, there are no triggers on the cache group, which is why the cache had to be removed separately above.
         SQLiteStatement groupStatement(m_database, "DELETE FROM CacheGroups WHERE id=?");
-        if (groupStatement.prepare() != SQLResultOk)
+        if (groupStatement.prepare() != SQLITE_OK)
             return;
         
         groupStatement.bindInt64(1, cache->group()->storageID());
@@ -1348,10 +1348,10 @@ bool ApplicationCacheStorage::getManifestURLs(Vector<URL>* urls)
 
     SQLiteStatement selectURLs(m_database, "SELECT manifestURL FROM CacheGroups");
 
-    if (selectURLs.prepare() != SQLResultOk)
+    if (selectURLs.prepare() != SQLITE_OK)
         return false;
 
-    while (selectURLs.step() == SQLResultRow)
+    while (selectURLs.step() == SQLITE_ROW)
         urls->append(URL(ParsedURLString, selectURLs.getColumnText(0)));
 
     return true;
@@ -1367,16 +1367,16 @@ bool ApplicationCacheStorage::cacheGroupSize(const String& manifestURL, int64_t*
         return false;
 
     SQLiteStatement statement(m_database, "SELECT sum(Caches.size) FROM Caches INNER JOIN CacheGroups ON Caches.cacheGroup=CacheGroups.id WHERE CacheGroups.manifestURL=?");
-    if (statement.prepare() != SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return false;
 
     statement.bindText(1, manifestURL);
 
     int result = statement.step();
-    if (result == SQLResultDone)
+    if (result == SQLITE_DONE)
         return false;
 
-    if (result != SQLResultRow) {
+    if (result != SQLITE_ROW) {
         LOG_ERROR("Could not get the size of the cache group, error \"%s\"", m_database.lastErrorMsg());
         return false;
     }
@@ -1389,23 +1389,23 @@ bool ApplicationCacheStorage::deleteCacheGroupRecord(const String& manifestURL)
 {
     ASSERT(SQLiteDatabaseTracker::hasTransactionInProgress());
     SQLiteStatement idStatement(m_database, "SELECT id FROM CacheGroups WHERE manifestURL=?");
-    if (idStatement.prepare() != SQLResultOk)
+    if (idStatement.prepare() != SQLITE_OK)
         return false;
 
     idStatement.bindText(1, manifestURL);
 
     int result = idStatement.step();
-    if (result != SQLResultRow)
+    if (result != SQLITE_ROW)
         return false;
 
     int64_t groupId = idStatement.getColumnInt64(0);
 
     SQLiteStatement cacheStatement(m_database, "DELETE FROM Caches WHERE cacheGroup=?");
-    if (cacheStatement.prepare() != SQLResultOk)
+    if (cacheStatement.prepare() != SQLITE_OK)
         return false;
 
     SQLiteStatement groupStatement(m_database, "DELETE FROM CacheGroups WHERE id=?");
-    if (groupStatement.prepare() != SQLResultOk)
+    if (groupStatement.prepare() != SQLITE_OK)
         return false;
 
     cacheStatement.bindInt64(1, groupId);
@@ -1455,7 +1455,7 @@ void ApplicationCacheStorage::vacuumDatabaseFile()
 
 void ApplicationCacheStorage::checkForMaxSizeReached()
 {
-    if (m_database.lastError() == SQLResultFull)
+    if (m_database.lastError() == SQLITE_FULL)
         m_isMaximumSizeReached = true;
 }
     
@@ -1472,10 +1472,10 @@ void ApplicationCacheStorage::checkForDeletedResources()
         "ON DeletedCacheResources.path = CacheResourceData.path "
         "WHERE (SELECT DeletedCacheResources.path == CacheResourceData.path) IS NULL");
     
-    if (selectPaths.prepare() != SQLResultOk)
+    if (selectPaths.prepare() != SQLITE_OK)
         return;
     
-    if (selectPaths.step() != SQLResultRow)
+    if (selectPaths.step() != SQLITE_ROW)
         return;
     
     do {
@@ -1492,7 +1492,7 @@ void ApplicationCacheStorage::checkForDeletedResources()
             continue;
         
         deleteFile(fullPath);
-    } while (selectPaths.step() == SQLResultRow);
+    } while (selectPaths.step() == SQLITE_ROW);
     
     executeSQLCommand("DELETE FROM DeletedCacheResources");
 }
@@ -1505,14 +1505,14 @@ long long ApplicationCacheStorage::flatFileAreaSize()
     
     SQLiteStatement selectPaths(m_database, "SELECT path FROM CacheResourceData WHERE path NOT NULL");
 
-    if (selectPaths.prepare() != SQLResultOk) {
+    if (selectPaths.prepare() != SQLITE_OK) {
         LOG_ERROR("Could not load flat file cache resource data, error \"%s\"", m_database.lastErrorMsg());
         return 0;
     }
 
     long long totalSize = 0;
     String flatFileDirectory = pathByAppendingComponent(m_cacheDirectory, flatFileSubdirectory);
-    while (selectPaths.step() == SQLResultRow) {
+    while (selectPaths.step() == SQLITE_ROW) {
         String path = selectPaths.getColumnText(0);
         String fullPath = pathByAppendingComponent(flatFileDirectory, path);
         long long pathSize = 0;
index 35e8e9d..6f53042 100644 (file)
@@ -1159,16 +1159,16 @@ bool IconDatabase::checkIntegrity()
     ASSERT_ICON_SYNC_THREAD();
     
     SQLiteStatement integrity(m_syncDB, "PRAGMA integrity_check;");
-    if (integrity.prepare() != SQLResultOk) {
+    if (integrity.prepare() != SQLITE_OK) {
         LOG_ERROR("checkIntegrity failed to execute");
         return false;
     }
     
     int resultCode = integrity.step();
-    if (resultCode == SQLResultOk)
+    if (resultCode == SQLITE_OK)
         return true;
-        
-    if (resultCode != SQLResultRow)
+
+    if (resultCode != SQLITE_ROW)
         return false;
 
     int columns = integrity.columnCount();
@@ -1203,13 +1203,13 @@ void IconDatabase::performURLImport()
 
     SQLiteStatement query(m_syncDB, importQuery);
     
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to prepare icon url import query");
         return;
     }
     
     int result = query.step();
-    while (result == SQLResultRow) {
+    while (result == SQLITE_ROW) {
         AutodrainedPool pool;
         String pageURL = query.getColumnText(0);
         String iconURL = query.getColumnText(1);
@@ -1264,7 +1264,7 @@ void IconDatabase::performURLImport()
         result = query.step();
     }
     
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG(IconDatabase, "Error reading page->icon url mappings from database");
 
     // Clear the m_pageURLsPendingImport set - either the page URLs ended up with an iconURL (that we'll notify about) or not, 
@@ -1657,13 +1657,13 @@ void IconDatabase::pruneUnretainedIcons()
     pageSQL.prepare();
     
     int result;
-    while ((result = pageSQL.step()) == SQLResultRow) {
+    while ((result = pageSQL.step()) == SQLITE_ROW) {
         MutexLocker locker(m_urlAndIconLock);
         if (!m_pageURLToRecordMap.contains(pageSQL.getColumnText(1)))
             pageIDsToDelete.append(pageSQL.getColumnInt64(0));
     }
     
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Error reading PageURL table from on-disk DB");
     pageSQL.finalize();
     
@@ -1679,7 +1679,7 @@ void IconDatabase::pruneUnretainedIcons()
             LOG(IconDatabase, "Pruning page with rowid %lli from disk", static_cast<long long>(pageIDsToDelete[i]));
             pageDeleteSQL.bindInt64(1, pageIDsToDelete[i]);
             int result = pageDeleteSQL.step();
-            if (result != SQLResultDone)
+            if (result != SQLITE_DONE)
                 LOG_ERROR("Unabled to delete page with id %lli from disk", static_cast<long long>(pageIDsToDelete[i]));
             pageDeleteSQL.reset();
             
@@ -1819,7 +1819,7 @@ inline void readySQLiteStatement(std::unique_ptr<SQLiteStatement>& statement, SQ
     }
     if (!statement) {
         statement = std::make_unique<SQLiteStatement>(db, str);
-        if (statement->prepare() != SQLResultOk)
+        if (statement->prepare() != SQLITE_OK)
             LOG_ERROR("Preparing statement %s failed", str.ascii().data());
     }
 }
@@ -1851,7 +1851,7 @@ void IconDatabase::setIconIDForPageURLInSQLDatabase(int64_t iconID, const String
     m_setIconIDForPageURLStatement->bindInt64(2, iconID);
 
     int result = m_setIconIDForPageURLStatement->step();
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         ASSERT_NOT_REACHED();
         LOG_ERROR("setIconIDForPageURLQuery failed for url %s", urlForLogging(pageURL).ascii().data());
     }
@@ -1866,7 +1866,7 @@ void IconDatabase::removePageURLFromSQLDatabase(const String& pageURL)
     readySQLiteStatement(m_removePageURLStatement, m_syncDB, "DELETE FROM PageURL WHERE url = (?);");
     m_removePageURLStatement->bindText(1, pageURL);
 
-    if (m_removePageURLStatement->step() != SQLResultDone)
+    if (m_removePageURLStatement->step() != SQLITE_DONE)
         LOG_ERROR("removePageURLFromSQLDatabase failed for url %s", urlForLogging(pageURL).ascii().data());
     
     m_removePageURLStatement->reset();
@@ -1881,10 +1881,10 @@ int64_t IconDatabase::getIconIDForIconURLFromSQLDatabase(const String& iconURL)
     m_getIconIDForIconURLStatement->bindText(1, iconURL);
     
     int64_t result = m_getIconIDForIconURLStatement->step();
-    if (result == SQLResultRow)
+    if (result == SQLITE_ROW)
         result = m_getIconIDForIconURLStatement->getColumnInt64(0);
     else {
-        if (result != SQLResultDone)
+        if (result != SQLITE_DONE)
             LOG_ERROR("getIconIDForIconURLFromSQLDatabase failed for url %s", urlForLogging(iconURL).ascii().data());
         result = 0;
     }
@@ -1906,7 +1906,7 @@ int64_t IconDatabase::addIconURLToSQLDatabase(const String& iconURL)
     
     int result = m_addIconToIconInfoStatement->step();
     m_addIconToIconInfoStatement->reset();
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("addIconURLToSQLDatabase failed to insert %s into IconInfo", urlForLogging(iconURL).ascii().data());
         return 0;
     }
@@ -1917,7 +1917,7 @@ int64_t IconDatabase::addIconURLToSQLDatabase(const String& iconURL)
     
     result = m_addIconToIconDataStatement->step();
     m_addIconToIconDataStatement->reset();
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("addIconURLToSQLDatabase failed to insert %s into IconData", urlForLogging(iconURL).ascii().data());
         return 0;
     }
@@ -1935,11 +1935,11 @@ PassRefPtr<SharedBuffer> IconDatabase::getImageDataForIconURLFromSQLDatabase(con
     m_getImageDataForIconURLStatement->bindText(1, iconURL);
     
     int result = m_getImageDataForIconURLStatement->step();
-    if (result == SQLResultRow) {
+    if (result == SQLITE_ROW) {
         Vector<char> data;
         m_getImageDataForIconURLStatement->getColumnBlobAsVector(0, data);
         imageData = SharedBuffer::create(data.data(), data.size());
-    } else if (result != SQLResultDone)
+    } else if (result != SQLITE_DONE)
         LOG_ERROR("getImageDataForIconURLFromSQLDatabase failed for url %s", urlForLogging(iconURL).ascii().data());
 
     m_getImageDataForIconURLStatement->reset();
@@ -1966,21 +1966,21 @@ void IconDatabase::removeIconFromSQLDatabase(const String& iconURL)
     readySQLiteStatement(m_deletePageURLsForIconURLStatement, m_syncDB, "DELETE FROM PageURL WHERE PageURL.iconID = (?);");
     m_deletePageURLsForIconURLStatement->bindInt64(1, iconID);
     
-    if (m_deletePageURLsForIconURLStatement->step() != SQLResultDone)
+    if (m_deletePageURLsForIconURLStatement->step() != SQLITE_DONE)
         LOG_ERROR("m_deletePageURLsForIconURLStatement failed for url %s", urlForLogging(iconURL).ascii().data());
     
     readySQLiteStatement(m_deleteIconFromIconInfoStatement, m_syncDB, "DELETE FROM IconInfo WHERE IconInfo.iconID = (?);");
     m_deleteIconFromIconInfoStatement->bindInt64(1, iconID);
     
-    if (m_deleteIconFromIconInfoStatement->step() != SQLResultDone)
+    if (m_deleteIconFromIconInfoStatement->step() != SQLITE_DONE)
         LOG_ERROR("m_deleteIconFromIconInfoStatement failed for url %s", urlForLogging(iconURL).ascii().data());
-        
+
     readySQLiteStatement(m_deleteIconFromIconDataStatement, m_syncDB, "DELETE FROM IconData WHERE IconData.iconID = (?);");
     m_deleteIconFromIconDataStatement->bindInt64(1, iconID);
     
-    if (m_deleteIconFromIconDataStatement->step() != SQLResultDone)
+    if (m_deleteIconFromIconDataStatement->step() != SQLITE_DONE)
         LOG_ERROR("m_deleteIconFromIconDataStatement failed for url %s", urlForLogging(iconURL).ascii().data());
-        
+
     m_deletePageURLsForIconURLStatement->reset();
     m_deleteIconFromIconInfoStatement->reset();
     m_deleteIconFromIconDataStatement->reset();
@@ -2014,7 +2014,7 @@ void IconDatabase::writeIconSnapshotToSQLDatabase(const IconSnapshot& snapshot)
         m_updateIconInfoStatement->bindText(2, snapshot.iconURL());
         m_updateIconInfoStatement->bindInt64(3, iconID);
 
-        if (m_updateIconInfoStatement->step() != SQLResultDone)
+        if (m_updateIconInfoStatement->step() != SQLITE_DONE)
             LOG_ERROR("Failed to update icon info for url %s", urlForLogging(snapshot.iconURL()).ascii().data());
         
         m_updateIconInfoStatement->reset();
@@ -2029,7 +2029,7 @@ void IconDatabase::writeIconSnapshotToSQLDatabase(const IconSnapshot& snapshot)
         else
             m_updateIconDataStatement->bindNull(1);
         
-        if (m_updateIconDataStatement->step() != SQLResultDone)
+        if (m_updateIconDataStatement->step() != SQLITE_DONE)
             LOG_ERROR("Failed to update icon data for url %s", urlForLogging(snapshot.iconURL()).ascii().data());
 
         m_updateIconDataStatement->reset();
@@ -2038,7 +2038,7 @@ void IconDatabase::writeIconSnapshotToSQLDatabase(const IconSnapshot& snapshot)
         m_setIconInfoStatement->bindText(1, snapshot.iconURL());
         m_setIconInfoStatement->bindInt64(2, snapshot.timestamp());
 
-        if (m_setIconInfoStatement->step() != SQLResultDone)
+        if (m_setIconInfoStatement->step() != SQLITE_DONE)
             LOG_ERROR("Failed to set icon info for url %s", urlForLogging(snapshot.iconURL()).ascii().data());
         
         m_setIconInfoStatement->reset();
@@ -2055,7 +2055,7 @@ void IconDatabase::writeIconSnapshotToSQLDatabase(const IconSnapshot& snapshot)
         else
             m_setIconDataStatement->bindNull(2);
         
-        if (m_setIconDataStatement->step() != SQLResultDone)
+        if (m_setIconDataStatement->step() != SQLITE_DONE)
             LOG_ERROR("Failed to set icon data for url %s", urlForLogging(snapshot.iconURL()).ascii().data());
 
         m_setIconDataStatement->reset();
index e150855..0fe27d6 100644 (file)
@@ -31,7 +31,6 @@
 #include "Logging.h"
 #include "SQLiteFileSystem.h"
 #include "SQLiteStatement.h"
-#include <sqlite3.h>
 #include <thread>
 #include <wtf/Threading.h>
 #include <wtf/text/CString.h>
 
 namespace WebCore {
 
-WEBCORE_EXPORT const int SQLResultDone = SQLITE_DONE;
-const int SQLResultError = SQLITE_ERROR;
-WEBCORE_EXPORT const int SQLResultOk = SQLITE_OK;
-WEBCORE_EXPORT const int SQLResultRow = SQLITE_ROW;
-const int SQLResultSchema = SQLITE_SCHEMA;
-const int SQLResultFull = SQLITE_FULL;
-const int SQLResultInterrupt = SQLITE_INTERRUPT;
-WEBCORE_EXPORT const int SQLResultConstraint = SQLITE_CONSTRAINT;
-
 static const char notOpenErrorMessage[] = "database is not open";
 
 SQLiteDatabase::SQLiteDatabase()
@@ -191,7 +181,7 @@ void SQLiteDatabase::setMaximumSize(int64_t size)
 
     SQLiteStatement statement(*this, "PRAGMA max_page_count = " + String::number(newMaxPageCount));
     statement.prepare();
-    if (statement.step() != SQLResultRow)
+    if (statement.step() != SQLITE_ROW)
         LOG_ERROR("Failed to set maximum size of database to %lli bytes", static_cast<long long>(size));
 
     enableAuthorizer(true);
index f912d03..07ca930 100644 (file)
@@ -28,6 +28,7 @@
 #define SQLiteDatabase_h
 
 #include <functional>
+#include <sqlite3.h>
 #include <wtf/Threading.h>
 #include <wtf/text/CString.h>
 #include <wtf/text/WTFString.h>
@@ -44,15 +45,6 @@ class DatabaseAuthorizer;
 class SQLiteStatement;
 class SQLiteTransaction;
 
-WEBCORE_EXPORT extern const int SQLResultDone;
-extern const int SQLResultError;
-WEBCORE_EXPORT extern const int SQLResultOk;
-WEBCORE_EXPORT extern const int SQLResultRow;
-extern const int SQLResultSchema;
-extern const int SQLResultFull;
-extern const int SQLResultInterrupt;
-WEBCORE_EXPORT extern const int SQLResultConstraint;
-
 class SQLiteDatabase {
     WTF_MAKE_NONCOPYABLE(SQLiteDatabase);
     friend class SQLiteTransaction;
index 3bc050c..30f7a83 100644 (file)
@@ -59,13 +59,13 @@ String SQLiteFileSystem::getFileNameForNewDatabase(const String& dbDir, const St
     // try to get the next sequence number from the given database
     // if we can't get a number, return an empty string
     SQLiteStatement sequenceStatement(*db, "SELECT seq FROM sqlite_sequence WHERE name='Databases';");
-    if (sequenceStatement.prepare() != SQLResultOk)
+    if (sequenceStatement.prepare() != SQLITE_OK)
         return String();
     int result = sequenceStatement.step();
     int64_t seq = 0;
-    if (result == SQLResultRow)
+    if (result == SQLITE_ROW)
         seq = sequenceStatement.getColumnInt64(0);
-    else if (result != SQLResultDone)
+    else if (result != SQLITE_DONE)
         return String();
     sequenceStatement.finalize();
 
index 3ff6167..816e996 100644 (file)
@@ -91,7 +91,6 @@ int SQLiteStatement::step()
     MutexLocker databaseLock(m_database.databaseMutex());
     if (m_database.isInterrupted())
         return SQLITE_INTERRUPT;
-    //ASSERT(m_isPrepared);
 
     if (!m_statement)
         return SQLITE_OK;
@@ -486,7 +485,7 @@ bool SQLiteStatement::returnIntResults(int col, Vector<int>& v)
         finalize();
     if (prepare() != SQLITE_OK)
         return false;
-        
+
     while (step() == SQLITE_ROW)
         v.append(getColumnInt(col));
     bool result = true;
@@ -506,7 +505,7 @@ bool SQLiteStatement::returnInt64Results(int col, Vector<int64_t>& v)
         finalize();
     if (prepare() != SQLITE_OK)
         return false;
-        
+
     while (step() == SQLITE_ROW)
         v.append(getColumnInt64(col));
     bool result = true;
index 2f354e0..8768c5c 100644 (file)
@@ -1,3 +1,26 @@
+2015-04-05  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
+
+        Use constants of sqlite3 directly for status of SQL result in webdatabase
+        https://bugs.webkit.org/show_bug.cgi?id=143329
+
+        Reviewed by Darin Adler.
+
+        In webdatabase, it has used own constants vairables as well as using sqlite3 constants directly.
+        It causes to use if~else statement which consumes more cpu cycles compared to switch~case. This
+        patch makes to use constants of sqlite3.
+
+        * Storage/StorageAreaSync.cpp:
+        (WebCore::StorageAreaSync::performImport):
+        (WebCore::StorageAreaSync::sync):
+        (WebCore::StorageAreaSync::deleteEmptyDatabase):
+        * Storage/StorageTracker.cpp:
+        (WebCore::StorageTracker::syncImportOriginIdentifiers):
+        (WebCore::StorageTracker::syncSetOriginDetails):
+        (WebCore::StorageTracker::syncDeleteAllOrigins):
+        (WebCore::StorageTracker::syncDeleteOrigin):
+        (WebCore::StorageTracker::databasePathForOrigin):
+        * WebKit.vcxproj/WebKit/WebKitCommon.props: Add sqlite include path.
+
 2015-04-01  Alex Christensen  <achristensen@webkit.org>
 
         Progress towards CMake on Windows and Mac.
index 01d9e92..d1eb32a 100644 (file)
@@ -325,7 +325,7 @@ void StorageAreaSync::performImport()
     }
 
     SQLiteStatement query(m_database, "SELECT key, value FROM ItemTable");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to select items from ItemTable for local storage");
         markImported();
         return;
@@ -334,12 +334,12 @@ void StorageAreaSync::performImport()
     HashMap<String, String> itemMap;
 
     int result = query.step();
-    while (result == SQLResultRow) {
+    while (result == SQLITE_ROW) {
         itemMap.set(query.getColumnText(0), query.getColumnBlobAsString(1));
         result = query.step();
     }
 
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("Error reading items from ItemTable for local storage");
         markImported();
         return;
@@ -411,26 +411,26 @@ void StorageAreaSync::sync(bool clearItems, const HashMap<String, String>& items
     // If the clear flag is set, then we clear all items out before we write any new ones in.
     if (clearItems) {
         SQLiteStatement clear(m_database, "DELETE FROM ItemTable");
-        if (clear.prepare() != SQLResultOk) {
+        if (clear.prepare() != SQLITE_OK) {
             LOG_ERROR("Failed to prepare clear statement - cannot write to local storage database");
             return;
         }
 
         int result = clear.step();
-        if (result != SQLResultDone) {
+        if (result != SQLITE_DONE) {
             LOG_ERROR("Failed to clear all items in the local storage database - %i", result);
             return;
         }
     }
 
     SQLiteStatement insert(m_database, "INSERT INTO ItemTable VALUES (?, ?)");
-    if (insert.prepare() != SQLResultOk) {
+    if (insert.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare insert statement - cannot write to local storage database");
         return;
     }
 
     SQLiteStatement remove(m_database, "DELETE FROM ItemTable WHERE key=?");
-    if (remove.prepare() != SQLResultOk) {
+    if (remove.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare delete statement - cannot write to local storage database");
         return;
     }
@@ -450,7 +450,7 @@ void StorageAreaSync::sync(bool clearItems, const HashMap<String, String>& items
             query.bindBlob(2, it->value);
 
         int result = query.step();
-        if (result != SQLResultDone) {
+        if (result != SQLITE_DONE) {
             LOG_ERROR("Failed to update item in the local storage database - %i", result);
             break;
         }
@@ -498,13 +498,13 @@ void StorageAreaSync::deleteEmptyDatabase()
         return;
 
     SQLiteStatement query(m_database, "SELECT COUNT(*) FROM ItemTable");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to count number of rows in ItemTable for local storage");
         return;
     }
 
     int result = query.step();
-    if (result != SQLResultRow) {
+    if (result != SQLITE_ROW) {
         LOG_ERROR("No results when counting number of rows in ItemTable for local storage");
         return;
     }
index 3c4e613..9fc09ba 100644 (file)
@@ -209,7 +209,7 @@ void StorageTracker::syncImportOriginIdentifiers()
             SQLiteTransactionInProgressAutoCounter transactionCounter;
 
             SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
-            if (statement.prepare() != SQLResultOk) {
+            if (statement.prepare() != SQLITE_OK) {
                 LOG_ERROR("Failed to prepare statement.");
                 return;
             }
@@ -218,11 +218,11 @@ void StorageTracker::syncImportOriginIdentifiers()
             
             {
                 MutexLocker lockOrigins(m_originSetMutex);
-                while ((result = statement.step()) == SQLResultRow)
+                while ((result = statement.step()) == SQLITE_ROW)
                     m_originSet.add(statement.getColumnText(0).isolatedCopy());
             }
             
-            if (result != SQLResultDone) {
+            if (result != SQLITE_DONE) {
                 LOG_ERROR("Failed to read in all origins from the database.");
                 return;
             }
@@ -345,7 +345,7 @@ void StorageTracker::syncSetOriginDetails(const String& originIdentifier, const
         return;
 
     SQLiteStatement statement(m_database, "INSERT INTO Origins VALUES (?, ?)");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.ascii().data());
         return;
     } 
@@ -353,7 +353,7 @@ void StorageTracker::syncSetOriginDetails(const String& originIdentifier, const
     statement.bindText(1, originIdentifier);
     statement.bindText(2, databaseFile);
     
-    if (statement.step() != SQLResultDone)
+    if (statement.step() != SQLITE_DONE)
         LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.ascii().data());
 
     {
@@ -424,13 +424,13 @@ void StorageTracker::syncDeleteAllOrigins()
         return;
     
     SQLiteStatement statement(m_database, "SELECT origin, path FROM Origins");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare statement.");
         return;
     }
     
     int result;
-    while ((result = statement.step()) == SQLResultRow) {
+    while ((result = statement.step()) == SQLITE_ROW) {
         if (!canDeleteOrigin(statement.getColumnText(0)))
             continue;
 
@@ -443,7 +443,7 @@ void StorageTracker::syncDeleteAllOrigins()
         }
     }
     
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Failed to read in all origins from the database.");
 
     if (m_database.isOpen()) {
@@ -461,7 +461,7 @@ void StorageTracker::syncDeleteAllOrigins()
         if (!m_database.isOpen())
             return;
         SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins");
-        if (deleteStatement.prepare() != SQLResultOk) {
+        if (deleteStatement.prepare() != SQLITE_OK) {
             LOG_ERROR("Unable to prepare deletion of all origins");
             return;
         }
@@ -535,7 +535,7 @@ void StorageTracker::syncDeleteOrigin(const String& originIdentifier)
     }
     
     SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins where origin=?");
-    if (deleteStatement.prepare() != SQLResultOk) {
+    if (deleteStatement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to prepare deletion of origin '%s'", originIdentifier.ascii().data());
         return;
     }
@@ -630,13 +630,13 @@ String StorageTracker::databasePathForOrigin(const String& originIdentifier)
     SQLiteTransactionInProgressAutoCounter transactionCounter;
 
     SQLiteStatement pathStatement(m_database, "SELECT path FROM Origins WHERE origin=?");
-    if (pathStatement.prepare() != SQLResultOk) {
+    if (pathStatement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to prepare selection of path for origin '%s'", originIdentifier.ascii().data());
         return String();
     }
     pathStatement.bindText(1, originIdentifier);
     int result = pathStatement.step();
-    if (result != SQLResultRow)
+    if (result != SQLITE_ROW)
         return String();
 
     return pathStatement.getColumnText(0);
index 111a162..4cf6556 100644 (file)
@@ -5,7 +5,7 @@
   </PropertyGroup>
   <ItemDefinitionGroup>
     <ClCompile>
-      <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)\..\..\win;$(ProjectDir)\..\..\win\Plugins;$(ProjectDir)\..\..\win\WebCoreSupport;$(ProjectDir)\..\..\Storage;$(ConfigurationBuildDir)\include\WebKit;$(ConfigurationBuildDir)\Include;$(ConfigurationBuildDir)\Include\private;$(ConfigurationBuildDir)\Include\WebCore;$(ConfigurationBuildDir)\Include\WebCore\ForwardingHeaders;$(ConfigurationBuildDir)\Include\JavaScriptCore;$(ConfigurationBuildDir)\Include\private\JavaScriptCore;$(ConfigurationBuildDir)\obj$(PlatformArchitecture)\WebKit\DerivedSources;$(WebKit_Libraries)\Include;$(WebKit_Libraries)\Include\private;$(WebKit_Libraries)\Include\WebCore;$(WebKit_Libraries)\Include\WebCore\ForwardingHeaders;$(WebKit_Libraries)\Include\JavaScriptCore;$(WebKit_Libraries)\Include\private\JavaScriptCore;$(IntDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)\..\..\win;$(ProjectDir)\..\..\win\Plugins;$(ProjectDir)\..\..\win\WebCoreSupport;$(ProjectDir)\..\..\Storage;$(ConfigurationBuildDir)\include\WebKit;$(ConfigurationBuildDir)\Include;$(ConfigurationBuildDir)\Include\private;$(ConfigurationBuildDir)\Include\WebCore;$(ConfigurationBuildDir)\Include\WebCore\ForwardingHeaders;$(ConfigurationBuildDir)\Include\JavaScriptCore;$(ConfigurationBuildDir)\Include\private\JavaScriptCore;$(ConfigurationBuildDir)\obj$(PlatformArchitecture)\WebKit\DerivedSources;$(WebKit_Libraries)\Include;$(WebKit_Libraries)\Include\private;$(WebKit_Libraries)\Include\WebCore;$(WebKit_Libraries)\Include\WebCore\ForwardingHeaders;$(WebKit_Libraries)\include\sqlite;$(WebKit_Libraries)\Include\JavaScriptCore;$(WebKit_Libraries)\Include\private\JavaScriptCore;$(IntDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WEBKIT_EXPORTS;FRAMEWORK_NAME=WebKit;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <PrecompiledHeaderFile>WebKitPrefix.h</PrecompiledHeaderFile>
index d3a946e..eadde5b 100644 (file)
@@ -1,3 +1,58 @@
+2015-04-05  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
+
+        Use constants of sqlite3 directly for status of SQL result in webdatabase
+        https://bugs.webkit.org/show_bug.cgi?id=143329
+
+        Reviewed by Darin Adler.
+
+        In webdatabase, it has used own constant variables as well as using sqlite3 constants directly.
+        If sqlite3 constants are changed in the library, we should modify many files as well. Besides
+        it can cause to use if~else statement which consumes more cpu cycles compared to switch~case.
+
+        * DatabaseProcess/IndexedDB/sqlite/SQLiteIDBCursor.cpp:
+        (WebKit::SQLiteIDBCursor::createSQLiteStatement):
+        (WebKit::SQLiteIDBCursor::resetAndRebindStatement):
+        (WebKit::SQLiteIDBCursor::bindArguments):
+        (WebKit::SQLiteIDBCursor::internalAdvanceOnce):
+        * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
+        (WebKit::createOrMigrateRecordsTableIfNecessary):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::createAndPopulateInitialMetadata):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::extractExistingMetadata):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::changeDatabaseVersion):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::createObjectStore):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::clearObjectStore):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::createIndex):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteIndex):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::generateKeyNumber):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::updateKeyGeneratorNumber):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::keyExistsInObjectStore):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::putRecord):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::uncheckedPutIndexRecord):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteRecord):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRecordFromObjectStore):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRangeRecordFromObjectStore):
+        * NetworkProcess/cache/NetworkCacheStatistics.cpp:
+        (WebKit::NetworkCache::executeSQLStatement):
+        (WebKit::NetworkCache::Statistics::initialize):
+        (WebKit::NetworkCache::Statistics::queryWasEverRequested):
+        (WebKit::NetworkCache::Statistics::addHashesToDatabase):
+        (WebKit::NetworkCache::Statistics::addStoreDecisionsToDatabase):
+        * UIProcess/Storage/LocalStorageDatabase.cpp:
+        (WebKit::LocalStorageDatabase::importItems):
+        (WebKit::LocalStorageDatabase::updateDatabaseWithChangedItems):
+        (WebKit::LocalStorageDatabase::databaseIsEmpty):
+        * UIProcess/Storage/LocalStorageDatabaseTracker.cpp:
+        (WebKit::LocalStorageDatabaseTracker::deleteAllDatabases):
+        (WebKit::LocalStorageDatabaseTracker::importOriginIdentifiers):
+        (WebKit::LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier):
+        (WebKit::LocalStorageDatabaseTracker::removeDatabaseWithOriginIdentifier):
+        (WebKit::LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier):
+        * WebProcess/Cookies/soup/WebKitSoupCookieJarSqlite.cpp:
+        (webkitSoupCookieJarSqliteLoad):
+        (webkitSoupCookieJarSqliteInsertCookie):
+        (webkitSoupCookieJarSqliteDeleteCookie):
+
 2015-04-05  Simon Fraser  <simon.fraser@apple.com>
 
         Remove "go ahead and" from comments
index 66a564e..abea1dd 100644 (file)
@@ -153,7 +153,7 @@ bool SQLiteIDBCursor::createSQLiteStatement(const String& sql)
 
     m_statement = std::make_unique<SQLiteStatement>(m_transaction->sqliteTransaction()->database(), sql);
 
-    if (m_statement->prepare() != SQLResultOk) {
+    if (m_statement->prepare() != SQLITE_OK) {
         LOG_ERROR("Could not create cursor statement (prepare/id) - '%s'", m_transaction->sqliteTransaction()->database().lastErrorMsg());
         return false;
     }
@@ -190,7 +190,7 @@ void SQLiteIDBCursor::resetAndRebindStatement()
     else
         m_currentUpperKey = m_currentKey;
 
-    if (m_statement->reset() != SQLResultOk) {
+    if (m_statement->reset() != SQLITE_OK) {
         LOG_ERROR("Could not reset cursor statement to respond to object store changes");
         return;
     }
@@ -200,19 +200,19 @@ void SQLiteIDBCursor::resetAndRebindStatement()
 
 bool SQLiteIDBCursor::bindArguments()
 {
-    if (m_statement->bindInt64(1, m_boundID) != SQLResultOk) {
+    if (m_statement->bindInt64(1, m_boundID) != SQLITE_OK) {
         LOG_ERROR("Could not bind id argument (bound ID)");
         return false;
     }
 
     RefPtr<SharedBuffer> buffer = serializeIDBKeyData(m_currentLowerKey);
-    if (m_statement->bindBlob(2, buffer->data(), buffer->size()) != SQLResultOk) {
+    if (m_statement->bindBlob(2, buffer->data(), buffer->size()) != SQLITE_OK) {
         LOG_ERROR("Could not create cursor statement (lower key)");
         return false;
     }
 
     buffer = serializeIDBKeyData(m_currentUpperKey);
-    if (m_statement->bindBlob(3, buffer->data(), buffer->size()) != SQLResultOk) {
+    if (m_statement->bindBlob(3, buffer->data(), buffer->size()) != SQLITE_OK) {
         LOG_ERROR("Could not create cursor statement (upper key)");
         return false;
     }
@@ -277,7 +277,7 @@ SQLiteIDBCursor::AdvanceResult SQLiteIDBCursor::internalAdvanceOnce()
     }
 
     int result = m_statement->step();
-    if (result == SQLResultDone) {
+    if (result == SQLITE_DONE) {
         m_completed = true;
 
         // When a cursor reaches its end, that is indicated by having undefined keys/values
@@ -288,7 +288,7 @@ SQLiteIDBCursor::AdvanceResult SQLiteIDBCursor::internalAdvanceOnce()
         return AdvanceResult::Success;
     }
 
-    if (result != SQLResultRow) {
+    if (result != SQLITE_ROW) {
         LOG_ERROR("Error advancing cursor - (%i) %s", result, m_transaction->sqliteTransaction()->database().lastErrorMsg());
         m_completed = true;
         m_errored = true;
@@ -331,9 +331,9 @@ SQLiteIDBCursor::AdvanceResult SQLiteIDBCursor::internalAdvanceOnce()
 
         SQLiteStatement objectStoreStatement(m_statement->database(), "SELECT value FROM Records WHERE key = CAST(? AS TEXT) and objectStoreID = ?;");
 
-        if (objectStoreStatement.prepare() != SQLResultOk
-            || objectStoreStatement.bindBlob(1, m_currentValueBuffer.data(), m_currentValueBuffer.size()) != SQLResultOk
-            || objectStoreStatement.bindInt64(2, m_objectStoreID) != SQLResultOk) {
+        if (objectStoreStatement.prepare() != SQLITE_OK
+            || objectStoreStatement.bindBlob(1, m_currentValueBuffer.data(), m_currentValueBuffer.size()) != SQLITE_OK
+            || objectStoreStatement.bindInt64(2, m_objectStoreID) != SQLITE_OK) {
             LOG_ERROR("Could not create index cursor statement into object store records (%i) '%s'", m_statement->database().lastError(), m_statement->database().lastErrorMsg());
             m_completed = true;
             m_errored = true;
@@ -342,9 +342,9 @@ SQLiteIDBCursor::AdvanceResult SQLiteIDBCursor::internalAdvanceOnce()
 
         int result = objectStoreStatement.step();
 
-        if (result == SQLResultRow)
+        if (result == SQLITE_ROW)
             objectStoreStatement.getColumnBlobAsVector(0, m_currentValueBuffer);
-        else if (result == SQLResultDone) {
+        else if (result == SQLITE_DONE) {
             // This indicates that the record we're trying to retrieve has been removed from the object store.
             // Skip over it.
             return AdvanceResult::ShouldAdvanceAgain;
index 6a68aaa..d860759 100644 (file)
@@ -113,7 +113,7 @@ static bool createOrMigrateRecordsTableIfNecessary(SQLiteDatabase& database)
     {
         // Fetch the schema for an existing records table.
         SQLiteStatement statement(database, "SELECT type, sql FROM sqlite_master WHERE tbl_name='Records'");
-        if (statement.prepare() != SQLResultOk) {
+        if (statement.prepare() != SQLITE_OK) {
             LOG_ERROR("Unable to prepare statement to fetch schema for the Records table.");
             return false;
         }
@@ -121,7 +121,7 @@ static bool createOrMigrateRecordsTableIfNecessary(SQLiteDatabase& database)
         int sqliteResult = statement.step();
 
         // If there is no Records table at all, create it and then bail.
-        if (sqliteResult == SQLResultDone) {
+        if (sqliteResult == SQLITE_DONE) {
             if (!database.executeCommand(v2RecordsTableSchema())) {
                 LOG_ERROR("Could not create Records table in database (%i) - %s", database.lastError(), database.lastErrorMsg());
                 return false;
@@ -130,7 +130,7 @@ static bool createOrMigrateRecordsTableIfNecessary(SQLiteDatabase& database)
             return true;
         }
 
-        if (sqliteResult != SQLResultRow) {
+        if (sqliteResult != SQLITE_ROW) {
             LOG_ERROR("Error executing statement to fetch schema for the Records table.");
             return false;
         }
@@ -236,9 +236,9 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::create
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO IDBDatabaseInfo VALUES ('MetadataVersion', ?);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt(1, currentMetadataVersion) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt(1, currentMetadataVersion) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not insert database metadata version into IDBDatabaseInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             m_sqliteDB = nullptr;
             return nullptr;
@@ -246,9 +246,9 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::create
     }
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO IDBDatabaseInfo VALUES ('DatabaseName', ?);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindText(1, m_identifier.databaseName()) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindText(1, m_identifier.databaseName()) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not insert database name into IDBDatabaseInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             m_sqliteDB = nullptr;
             return nullptr;
@@ -258,9 +258,9 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::create
         // Database versions are defined to be a uin64_t in the spec but sqlite3 doesn't support native binding of unsigned integers.
         // Therefore we'll store the version as a String.
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO IDBDatabaseInfo VALUES ('DatabaseVersion', ?);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindText(1, String::number(IDBDatabaseMetadata::NoIntVersion)) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindText(1, String::number(IDBDatabaseMetadata::NoIntVersion)) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not insert default version into IDBDatabaseInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             m_sqliteDB = nullptr;
             return nullptr;
@@ -322,11 +322,11 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::extrac
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("SELECT id, name, keyPath, autoInc, maxIndexID FROM ObjectStoreInfo;"));
-        if (sql.prepare() != SQLResultOk)
+        if (sql.prepare() != SQLITE_OK)
             return nullptr;
 
         int result = sql.step();
-        while (result == SQLResultRow) {
+        while (result == SQLITE_ROW) {
             IDBObjectStoreMetadata osMetadata;
             osMetadata.id = sql.getColumnInt64(0);
             osMetadata.name = sql.getColumnText(1);
@@ -346,7 +346,7 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::extrac
             result = sql.step();
         }
 
-        if (result != SQLResultDone) {
+        if (result != SQLITE_DONE) {
             LOG_ERROR("Error fetching object store metadata from database on disk");
             return nullptr;
         }
@@ -354,11 +354,11 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::extrac
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("SELECT id, name, objectStoreID, keyPath, isUnique, multiEntry FROM IndexInfo;"));
-        if (sql.prepare() != SQLResultOk)
+        if (sql.prepare() != SQLITE_OK)
             return nullptr;
 
         int result = sql.step();
-        while (result == SQLResultRow) {
+        while (result == SQLITE_ROW) {
             IDBIndexMetadata indexMetadata;
 
             indexMetadata.id = sql.getColumnInt64(0);
@@ -387,7 +387,7 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::extrac
             result = sql.step();
         }
 
-        if (result != SQLResultDone) {
+        if (result != SQLITE_DONE) {
             LOG_ERROR("Error fetching index metadata from database on disk");
             return nullptr;
         }
@@ -533,9 +533,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::changeDatabaseVersion(const IDBIdentif
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("UPDATE IDBDatabaseInfo SET value = ? where key = 'DatabaseVersion';"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindText(1, String::number(newVersion)) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindText(1, String::number(newVersion)) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not update database version in IDBDatabaseInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -568,13 +568,13 @@ bool UniqueIDBDatabaseBackingStoreSQLite::createObjectStore(const IDBIdentifier&
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO ObjectStoreInfo VALUES (?, ?, ?, ?, ?);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, metadata.id) != SQLResultOk
-            || sql.bindText(2, metadata.name) != SQLResultOk
-            || sql.bindBlob(3, keyPathBlob->data(), keyPathBlob->size()) != SQLResultOk
-            || sql.bindInt(4, metadata.autoIncrement) != SQLResultOk
-            || sql.bindInt64(5, metadata.maxIndexId) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, metadata.id) != SQLITE_OK
+            || sql.bindText(2, metadata.name) != SQLITE_OK
+            || sql.bindBlob(3, keyPathBlob->data(), keyPathBlob->size()) != SQLITE_OK
+            || sql.bindInt(4, metadata.autoIncrement) != SQLITE_OK
+            || sql.bindInt64(5, metadata.maxIndexId) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not add object store '%s' to ObjectStoreInfo table (%i) - %s", metadata.name.utf8().data(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -582,9 +582,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::createObjectStore(const IDBIdentifier&
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO KeyGenerators VALUES (?, 0);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, metadata.id) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, metadata.id) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not seed initial key generator value for ObjectStoreInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -612,9 +612,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore(const IDBIdentifier&
     // Delete the ObjectStore record
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM ObjectStoreInfo WHERE id = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete object store id %lli from ObjectStoreInfo table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -623,9 +623,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore(const IDBIdentifier&
     // Delete the ObjectStore's key generator record if there is one.
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM KeyGenerators WHERE objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete object store from KeyGenerators table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -634,9 +634,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore(const IDBIdentifier&
     // Delete all associated records
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM Records WHERE objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete records for object store %lli (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -645,9 +645,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore(const IDBIdentifier&
     // Delete all associated Indexes
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM IndexInfo WHERE objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index from IndexInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -656,9 +656,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore(const IDBIdentifier&
     // Delete all associated Index records
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM IndexRecords WHERE objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index records(%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -685,9 +685,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::clearObjectStore(const IDBIdentifier&
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM Records WHERE objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete records from object store id %lli (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -695,9 +695,9 @@ bool UniqueIDBDatabaseBackingStoreSQLite::clearObjectStore(const IDBIdentifier&
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM IndexRecords WHERE objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete records from index record store id %lli (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -729,14 +729,14 @@ bool UniqueIDBDatabaseBackingStoreSQLite::createIndex(const IDBIdentifier& trans
     }
 
     SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO IndexInfo VALUES (?, ?, ?, ?, ?, ?);"));
-    if (sql.prepare() != SQLResultOk
-        || sql.bindInt64(1, metadata.id) != SQLResultOk
-        || sql.bindText(2, metadata.name) != SQLResultOk
-        || sql.bindInt64(3, objectStoreID) != SQLResultOk
-        || sql.bindBlob(4, keyPathBlob->data(), keyPathBlob->size()) != SQLResultOk
-        || sql.bindInt(5, metadata.unique) != SQLResultOk
-        || sql.bindInt(6, metadata.multiEntry) != SQLResultOk
-        || sql.step() != SQLResultDone) {
+    if (sql.prepare() != SQLITE_OK
+        || sql.bindInt64(1, metadata.id) != SQLITE_OK
+        || sql.bindText(2, metadata.name) != SQLITE_OK
+        || sql.bindInt64(3, objectStoreID) != SQLITE_OK
+        || sql.bindBlob(4, keyPathBlob->data(), keyPathBlob->size()) != SQLITE_OK
+        || sql.bindInt(5, metadata.unique) != SQLITE_OK
+        || sql.bindInt(6, metadata.multiEntry) != SQLITE_OK
+        || sql.step() != SQLITE_DONE) {
         LOG_ERROR("Could not add index '%s' to IndexInfo table (%i) - %s", metadata.name.utf8().data(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
         return false;
     }
@@ -806,10 +806,10 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteIndex(const IDBIdentifier& trans
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM IndexInfo WHERE id = ? AND objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, indexID) != SQLResultOk
-            || sql.bindInt64(2, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, indexID) != SQLITE_OK
+            || sql.bindInt64(2, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index id %lli from IndexInfo table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -817,10 +817,10 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteIndex(const IDBIdentifier& trans
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM IndexRecords WHERE indexID = ? AND objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, indexID) != SQLResultOk
-            || sql.bindInt64(2, objectStoreID) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, indexID) != SQLITE_OK
+            || sql.bindInt64(2, objectStoreID) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index records for index id %lli from IndexRecords table (%i) - %s", indexID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -851,13 +851,13 @@ bool UniqueIDBDatabaseBackingStoreSQLite::generateKeyNumber(const IDBIdentifier&
     int64_t currentValue;
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("SELECT currentKey FROM KeyGenerators WHERE objectStoreID = ?;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK) {
             LOG_ERROR("Could not delete index id %lli from IndexInfo table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
         int result = sql.step();
-        if (result != SQLResultRow) {
+        if (result != SQLITE_ROW) {
             LOG_ERROR("Could not retreive key generator value for object store, but it should be there.");
             return false;
         }
@@ -890,10 +890,10 @@ bool UniqueIDBDatabaseBackingStoreSQLite::updateKeyGeneratorNumber(const IDBIden
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO KeyGenerators VALUES (?, ?);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.bindInt64(2, keyNumber) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.bindInt64(2, keyNumber) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not update key generator value (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -923,20 +923,20 @@ bool UniqueIDBDatabaseBackingStoreSQLite::keyExistsInObjectStore(const IDBIdenti
     }
 
     SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("SELECT key FROM Records WHERE objectStoreID = ? AND key = CAST(? AS TEXT) LIMIT 1;"));
-    if (sql.prepare() != SQLResultOk
-        || sql.bindInt64(1, objectStoreID) != SQLResultOk
-        || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLResultOk) {
+    if (sql.prepare() != SQLITE_OK
+        || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+        || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK) {
         LOG_ERROR("Could not get record from object store %lli from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
         return false;
     }
 
     int sqlResult = sql.step();
-    if (sqlResult == SQLResultOk || sqlResult == SQLResultDone) {
+    if (sqlResult == SQLITE_OK || sqlResult == SQLITE_DONE) {
         keyExists = false;
         return true;
     }
 
-    if (sqlResult != SQLResultRow) {
+    if (sqlResult != SQLITE_ROW) {
         // There was an error fetching the record from the database.
         LOG_ERROR("Could not check if key exists in object store (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
         return false;
@@ -969,11 +969,11 @@ bool UniqueIDBDatabaseBackingStoreSQLite::putRecord(const IDBIdentifier& transac
     }
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO Records VALUES (?, CAST(? AS TEXT), ?);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLResultOk
-            || sql.bindBlob(3, valueBuffer, valueSize) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK
+            || sql.bindBlob(3, valueBuffer, valueSize) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not put record for object store %lli in Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -1016,12 +1016,12 @@ bool UniqueIDBDatabaseBackingStoreSQLite::uncheckedPutIndexRecord(int64_t object
     }
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO IndexRecords VALUES (?, ?, CAST(? AS TEXT), CAST(? AS TEXT));"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, indexID) != SQLResultOk
-            || sql.bindInt64(2, objectStoreID) != SQLResultOk
-            || sql.bindBlob(3, indexKeyBuffer->data(), indexKeyBuffer->size()) != SQLResultOk
-            || sql.bindBlob(4, valueBuffer->data(), valueBuffer->size()) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, indexID) != SQLITE_OK
+            || sql.bindInt64(2, objectStoreID) != SQLITE_OK
+            || sql.bindBlob(3, indexKeyBuffer->data(), indexKeyBuffer->size()) != SQLITE_OK
+            || sql.bindBlob(4, valueBuffer->data(), valueBuffer->size()) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not put index record for index %lli in object store %lli in Records table (%i) - %s", indexID, objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -1162,10 +1162,10 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteRecord(SQLiteIDBTransaction& tra
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM Records WHERE objectStoreID = ? AND key = CAST(? AS TEXT);"));
 
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete record from object store %lli (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -1175,10 +1175,10 @@ bool UniqueIDBDatabaseBackingStoreSQLite::deleteRecord(SQLiteIDBTransaction& tra
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("DELETE FROM IndexRecords WHERE objectStoreID = ? AND value = CAST(? AS TEXT);"));
 
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLResultOk
-            || sql.step() != SQLResultDone) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK
+            || sql.step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete record from indexes for object store %lli (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
@@ -1207,19 +1207,19 @@ bool UniqueIDBDatabaseBackingStoreSQLite::getKeyRecordFromObjectStore(const IDBI
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("SELECT value FROM Records WHERE objectStoreID = ? AND key = CAST(? AS TEXT);"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLResultOk) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK) {
             LOG_ERROR("Could not get record from object store %lli from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
 
         int sqlResult = sql.step();
-        if (sqlResult == SQLResultOk || sqlResult == SQLResultDone) {
+        if (sqlResult == SQLITE_OK || sqlResult == SQLITE_DONE) {
             // There was no record for the key in the database.
             return true;
         }
-        if (sqlResult != SQLResultRow) {
+        if (sqlResult != SQLITE_ROW) {
             // There was an error fetching the record from the database.
             LOG_ERROR("Could not get record from object store %lli from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
@@ -1259,21 +1259,21 @@ bool UniqueIDBDatabaseBackingStoreSQLite::getKeyRangeRecordFromObjectStore(const
 
     {
         SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("SELECT value FROM Records WHERE objectStoreID = ? AND key >= CAST(? AS TEXT) AND key <= CAST(? AS TEXT) ORDER BY key;"));
-        if (sql.prepare() != SQLResultOk
-            || sql.bindInt64(1, objectStoreID) != SQLResultOk
-            || sql.bindBlob(2, lowerBuffer->data(), lowerBuffer->size()) != SQLResultOk
-            || sql.bindBlob(3, upperBuffer->data(), upperBuffer->size()) != SQLResultOk) {
+        if (sql.prepare() != SQLITE_OK
+            || sql.bindInt64(1, objectStoreID) != SQLITE_OK
+            || sql.bindBlob(2, lowerBuffer->data(), lowerBuffer->size()) != SQLITE_OK
+            || sql.bindBlob(3, upperBuffer->data(), upperBuffer->size()) != SQLITE_OK) {
             LOG_ERROR("Could not get key range record from object store %lli from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
         }
 
         int sqlResult = sql.step();
 
-        if (sqlResult == SQLResultOk || sqlResult == SQLResultDone) {
+        if (sqlResult == SQLITE_OK || sqlResult == SQLITE_DONE) {
             // There was no record for the key in the database.
             return true;
         }
-        if (sqlResult != SQLResultRow) {
+        if (sqlResult != SQLITE_ROW) {
             // There was an error fetching the record from the database.
             LOG_ERROR("Could not get record from object store %lli from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
             return false;
index fa83219..1b0f7b8 100644 (file)
@@ -65,7 +65,7 @@ static bool executeSQLStatement(WebCore::SQLiteStatement& statement)
     ASSERT(WebCore::SQLiteDatabaseTracker::hasTransactionInProgress());
     ASSERT(statement.database().isOpen());
 
-    if (statement.step() != WebCore::SQLResultDone) {
+    if (statement.step() != SQLITE_DONE) {
         LOG_ERROR("Network cache statistics: failed to execute statement \"%s\" error \"%s\"", statement.query().utf8().data(), statement.database().lastErrorMsg());
         return false;
     }
@@ -115,7 +115,7 @@ void Statistics::initialize(const String& databasePath)
         executeSQLCommand(m_database, ASCIILiteral("CREATE TABLE IF NOT EXISTS UncachedReason (hash TEXT PRIMARY KEY, reason INTEGER)"));
 
         WebCore::SQLiteStatement statement(m_database, ASCIILiteral("SELECT count(*) FROM AlreadyRequested"));
-        if (statement.prepareAndStep() != WebCore::SQLResultRow) {
+        if (statement.prepareAndStep() != SQLITE_ROW) {
             LOG_ERROR("Network cache statistics: Failed to count the number of rows in AlreadyRequested table");
             return;
         }
@@ -357,17 +357,17 @@ void Statistics::queryWasEverRequested(const String& hash, NeedUncachedReason ne
         if (m_database.isOpen()) {
             if (!wasAlreadyRequested) {
                 WebCore::SQLiteStatement statement(m_database, ASCIILiteral("SELECT hash FROM AlreadyRequested WHERE hash=?"));
-                if (statement.prepare() == WebCore::SQLResultOk) {
+                if (statement.prepare() == SQLITE_OK) {
                     statement.bindText(1, query.hash);
-                    wasAlreadyRequested = (statement.step() == WebCore::SQLResultRow);
+                    wasAlreadyRequested = (statement.step() == SQLITE_ROW);
                 }
             }
             if (wasAlreadyRequested && query.needUncachedReason) {
                 WebCore::SQLiteStatement statement(m_database, ASCIILiteral("SELECT reason FROM UncachedReason WHERE hash=?"));
                 storeDecision = StoreDecision::Yes;
-                if (statement.prepare() == WebCore::SQLResultOk) {
+                if (statement.prepare() == SQLITE_OK) {
                     statement.bindText(1, query.hash);
-                    if (statement.step() == WebCore::SQLResultRow)
+                    if (statement.step() == SQLITE_ROW)
                         storeDecision = static_cast<StoreDecision>(statement.getColumnInt(0));
                 }
             }
@@ -403,7 +403,7 @@ void Statistics::addHashesToDatabase(const Vector<StringCapture>& hashes)
     ASSERT(m_database.isOpen());
 
     WebCore::SQLiteStatement statement(m_database, ASCIILiteral("INSERT OR IGNORE INTO AlreadyRequested (hash) VALUES (?)"));
-    if (statement.prepare() != WebCore::SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return;
 
     for (auto& hash : hashes) {
@@ -421,7 +421,7 @@ void Statistics::addStoreDecisionsToDatabase(const Vector<std::pair<StringCaptur
     ASSERT(m_database.isOpen());
 
     WebCore::SQLiteStatement statement(m_database, ASCIILiteral("INSERT OR REPLACE INTO UncachedReason (hash, reason) VALUES (?, ?)"));
-    if (statement.prepare() != WebCore::SQLResultOk)
+    if (statement.prepare() != SQLITE_OK)
         return;
 
     for (auto& pair : storeDecisions) {
index d7ab615..db8fded 100644 (file)
@@ -172,7 +172,7 @@ void LocalStorageDatabase::importItems(StorageMap& storageMap)
         return;
 
     SQLiteStatement query(m_database, "SELECT key, value FROM ItemTable");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to select items from ItemTable for local storage");
         return;
     }
@@ -180,12 +180,12 @@ void LocalStorageDatabase::importItems(StorageMap& storageMap)
     HashMap<String, String> items;
 
     int result = query.step();
-    while (result == SQLResultRow) {
+    while (result == SQLITE_ROW) {
         items.set(query.getColumnText(0), query.getColumnBlobAsString(1));
         result = query.step();
     }
 
-    if (result != SQLResultDone) {
+    if (result != SQLITE_DONE) {
         LOG_ERROR("Error reading items from ItemTable for local storage");
         return;
     }
@@ -293,26 +293,26 @@ void LocalStorageDatabase::updateDatabaseWithChangedItems(const HashMap<String,
         m_shouldClearItems = false;
 
         SQLiteStatement clearStatement(m_database, "DELETE FROM ItemTable");
-        if (clearStatement.prepare() != SQLResultOk) {
+        if (clearStatement.prepare() != SQLITE_OK) {
             LOG_ERROR("Failed to prepare clear statement - cannot write to local storage database");
             return;
         }
 
         int result = clearStatement.step();
-        if (result != SQLResultDone) {
+        if (result != SQLITE_DONE) {
             LOG_ERROR("Failed to clear all items in the local storage database - %i", result);
             return;
         }
     }
 
     SQLiteStatement insertStatement(m_database, "INSERT INTO ItemTable VALUES (?, ?)");
-    if (insertStatement.prepare() != SQLResultOk) {
+    if (insertStatement.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare insert statement - cannot write to local storage database");
         return;
     }
 
     SQLiteStatement deleteStatement(m_database, "DELETE FROM ItemTable WHERE key=?");
-    if (deleteStatement.prepare() != SQLResultOk) {
+    if (deleteStatement.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare delete statement - cannot write to local storage database");
         return;
     }
@@ -331,7 +331,7 @@ void LocalStorageDatabase::updateDatabaseWithChangedItems(const HashMap<String,
             statement.bindBlob(2, it->value);
 
         int result = statement.step();
-        if (result != SQLResultDone) {
+        if (result != SQLITE_DONE) {
             LOG_ERROR("Failed to update item in the local storage database - %i", result);
             break;
         }
@@ -348,13 +348,13 @@ bool LocalStorageDatabase::databaseIsEmpty()
         return false;
 
     SQLiteStatement query(m_database, "SELECT COUNT(*) FROM ItemTable");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to count number of rows in ItemTable for local storage");
         return false;
     }
 
     int result = query.step();
-    if (result != SQLResultRow) {
+    if (result != SQLITE_ROW) {
         LOG_ERROR("No results when counting number of rows in ItemTable for local storage");
         return false;
     }
index dcb35c1..ee5bc8e 100644 (file)
@@ -86,19 +86,19 @@ void LocalStorageDatabaseTracker::deleteAllDatabases()
         return;
 
     SQLiteStatement statement(m_database, "SELECT origin, path FROM Origins");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Failed to prepare statement.");
         return;
     }
 
     int result;
-    while ((result = statement.step()) == SQLResultRow) {
+    while ((result = statement.step()) == SQLITE_ROW) {
         deleteFile(statement.getColumnText(1));
 
         // FIXME: Call out to the client.
     }
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         LOG_ERROR("Failed to read in all origins from the database.");
 
     if (m_database.isOpen())
@@ -112,7 +112,7 @@ void LocalStorageDatabaseTracker::deleteAllDatabases()
             return;
 
         SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins");
-        if (deleteStatement.prepare() != SQLResultOk) {
+        if (deleteStatement.prepare() != SQLITE_OK) {
             LOG_ERROR("Unable to prepare deletion of all origins");
             return;
         }
@@ -243,17 +243,17 @@ void LocalStorageDatabaseTracker::importOriginIdentifiers()
 
     if (m_database.isOpen()) {
         SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
-        if (statement.prepare() != SQLResultOk) {
+        if (statement.prepare() != SQLITE_OK) {
             LOG_ERROR("Failed to prepare statement.");
             return;
         }
 
         int result;
 
-        while ((result = statement.step()) == SQLResultRow)
+        while ((result = statement.step()) == SQLITE_ROW)
             m_origins.add(statement.getColumnText(0));
 
-        if (result != SQLResultDone) {
+        if (result != SQLITE_DONE) {
             LOG_ERROR("Failed to read in all origins from the database.");
             return;
         }
@@ -301,7 +301,7 @@ void LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier(const String&
         return;
 
     SQLiteStatement statement(m_database, "INSERT INTO Origins VALUES (?, ?)");
-    if (statement.prepare() != SQLResultOk) {
+    if (statement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.utf8().data());
         return;
     }
@@ -309,7 +309,7 @@ void LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier(const String&
     statement.bindText(1, originIdentifier);
     statement.bindText(2, databasePath);
 
-    if (statement.step() != SQLResultDone)
+    if (statement.step() != SQLITE_DONE)
         LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.utf8().data());
 
     m_origins.add(originIdentifier);
@@ -328,7 +328,7 @@ void LocalStorageDatabaseTracker::removeDatabaseWithOriginIdentifier(const Strin
         return;
 
     SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins where origin=?");
-    if (deleteStatement.prepare() != SQLResultOk) {
+    if (deleteStatement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to prepare deletion of origin '%s'", originIdentifier.ascii().data());
         return;
     }
@@ -357,7 +357,7 @@ String LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier(const St
         return String();
 
     SQLiteStatement pathStatement(m_database, "SELECT path FROM Origins WHERE origin=?");
-    if (pathStatement.prepare() != SQLResultOk) {
+    if (pathStatement.prepare() != SQLITE_OK) {
         LOG_ERROR("Unable to prepare selection of path for origin '%s'", originIdentifier.utf8().data());
         return String();
     }
@@ -365,7 +365,7 @@ String LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier(const St
     pathStatement.bindText(1, originIdentifier);
 
     int result = pathStatement.step();
-    if (result != SQLResultRow)
+    if (result != SQLITE_ROW)
         return String();
 
     return pathStatement.getColumnText(0);
index b60584c..369fabf 100644 (file)
@@ -93,7 +93,7 @@ static void webkitSoupCookieJarSqliteLoad(WebKitSoupCookieJarSqlite* sqliteJar)
     WebKitSoupCookieJarSqlitePrivate* priv = sqliteJar->priv;
     priv->isLoading = true;
     SQLiteStatement query(priv->database, "SELECT id, name, value, host, path, expiry, lastAccessed, isSecure, isHttpOnly FROM moz_cookies;");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         g_warning("Failed to prepare all cookies query");
         priv->isLoading = false;
         return;
@@ -102,7 +102,7 @@ static void webkitSoupCookieJarSqliteLoad(WebKitSoupCookieJarSqlite* sqliteJar)
     SoupCookieJar* jar = SOUP_COOKIE_JAR(sqliteJar);
     time_t now = floorf(currentTime());
     int result;
-    while ((result = query.step()) == SQLResultRow) {
+    while ((result = query.step()) == SQLITE_ROW) {
         int expireTime = query.getColumnInt(ColumnExpiry);
         if (now >= expireTime)
             continue;
@@ -118,7 +118,7 @@ static void webkitSoupCookieJarSqliteLoad(WebKitSoupCookieJarSqlite* sqliteJar)
         soup_cookie_jar_add_cookie(jar, cookie);
     }
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         g_warning("Error reading cookies from database");
     priv->isLoading = false;
 }
@@ -127,7 +127,7 @@ static bool webkitSoupCookieJarSqliteInsertCookie(WebKitSoupCookieJarSqlite* sql
 {
     WebKitSoupCookieJarSqlitePrivate* priv = sqliteJar->priv;
     SQLiteStatement query(priv->database, "INSERT INTO moz_cookies VALUES(NULL, ?, ?, ?, ?, ?, NULL, ?, ?);");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         g_warning("Failed to prepare insert cookies query");
         return false;
     }
@@ -139,7 +139,7 @@ static bool webkitSoupCookieJarSqliteInsertCookie(WebKitSoupCookieJarSqlite* sql
     query.bindInt(5, static_cast<int64_t>(soup_date_to_time_t(cookie->expires)));
     query.bindInt(6, cookie->secure);
     query.bindInt(7, cookie->http_only);
-    if (query.step() != SQLResultDone) {
+    if (query.step() != SQLITE_DONE) {
         g_warning("Error adding cookie (name=%s, domain=%s) to database", cookie->name, cookie->name);
         return false;
     }
@@ -151,14 +151,14 @@ static bool webkitSoupCookieJarSqliteDeleteCookie(WebKitSoupCookieJarSqlite* sql
 {
     WebKitSoupCookieJarSqlitePrivate* priv = sqliteJar->priv;
     SQLiteStatement query(priv->database, "DELETE FROM moz_cookies WHERE name = (?) AND host = (?);");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         g_warning("Failed to prepare delete cookies query");
         return false;
     }
 
     query.bindText(1, String::fromUTF8(cookie->name));
     query.bindText(2, String::fromUTF8(cookie->domain));
-    if (query.step() != SQLResultDone) {
+    if (query.step() != SQLITE_DONE) {
         g_warning("Error deleting cookie (name=%s, domain=%s) from database", cookie->name, cookie->name);
         return false;
     }