Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  * Copyright (C) 2013 Apple Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "config.h"
  31 #include "DatabaseBackendBase.h"
  32
  33 #if ENABLE(SQL_DATABASE)
  34
  35 #include "DatabaseAuthorizer.h"
  36 #include "DatabaseBackendContext.h"
  37 #include "DatabaseBase.h"
  38 #include "DatabaseContext.h"
  39 #include "DatabaseManager.h"
  40 #include "DatabaseTracker.h"
  41 #include "ExceptionCode.h"
  42 #include "Logging.h"
  43 #include "SQLiteStatement.h"
  44 #include "SQLiteTransaction.h"
  45 #include "SecurityOrigin.h"
  46 #include <wtf/HashMap.h>
  47 #include <wtf/HashSet.h>
  48 #include <wtf/NeverDestroyed.h>
  49 #include <wtf/PassRefPtr.h>
  50 #include <wtf/RefPtr.h>
  51 #include <wtf/StdLibExtras.h>
  52 #include <wtf/text/CString.h>
  53 #include <wtf/text/StringHash.h>
  54
  55 #if PLATFORM(IOS)
  56 #include "SQLiteDatabaseTracker.h"
  57 #endif
  58
  59 // Registering "opened" databases with the DatabaseTracker
  60 // =======================================================
  61 // The DatabaseTracker maintains a list of databases that have been
  62 // "opened" so that the client can call interrupt or delete on every database
  63 // associated with a DatabaseBackendContext.
  64 //
  65 // We will only call DatabaseTracker::addOpenDatabase() to add the database
  66 // to the tracker as opened when we've succeeded in opening the database,
  67 // and will set m_opened to true. Similarly, we only call
  68 // DatabaseTracker::removeOpenDatabase() to remove the database from the
  69 // tracker when we set m_opened to false in closeDatabase(). This sets up
  70 // a simple symmetry between open and close operations, and a direct
  71 // correlation to adding and removing databases from the tracker's list,
  72 // thus ensuring that we have a correct list for the interrupt and
  73 // delete operations to work on.
  74 //
  75 // The only databases instances not tracked by the tracker's open database
  76 // list are the ones that have not been added yet, or the ones that we
  77 // attempted an open on but failed to. Such instances only exist in the
  78 // DatabaseServer's factory methods for creating database backends.
  79 //
  80 // The factory methods will either call openAndVerifyVersion() or
  81 // performOpenAndVerify(). These methods will add the newly instantiated
  82 // database backend if they succeed in opening the requested database.
  83 // In the case of failure to open the database, the factory methods will
  84 // simply discard the newly instantiated database backend when they return.
  85 // The ref counting mechanims will automatically destruct the un-added
  86 // (and un-returned) databases instances.
  87
  88 namespace WebCore {
  89
  90 static const char versionKey[] = "WebKitDatabaseVersionKey";
  91 static const char infoTableName[] = "__WebKitDatabaseInfoTable__";
  92
  93 static String formatErrorMessage(const char* message, int sqliteErrorCode, const char* sqliteErrorMessage)
  94 {
  95     return String::format("%s (%d %s)", message, sqliteErrorCode, sqliteErrorMessage);
  96 }
  97
  98 static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& query, String& resultString)
  99 {
 100     SQLiteStatement statement(db, query);
 101     int result = statement.prepare();
 102
 103     if (result != SQLResultOk) {
 104         LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
 105         return false;
 106     }
 107
 108     result = statement.step();
 109     if (result == SQLResultRow) {
 110         resultString = statement.getColumnText(0);
 111         return true;
 112     }
 113     if (result == SQLResultDone) {
 114         resultString = String();
 115         return true;
 116     }
 117
 118     LOG_ERROR("Error (%i) reading text result from database (%s)", result, query.ascii().data());
 119     return false;
 120 }
 121
 122 static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, const String& value)
 123 {
 124     SQLiteStatement statement(db, query);
 125     int result = statement.prepare();
 126
 127     if (result != SQLResultOk) {
 128         LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
 129         return false;
 130     }
 131
 132     statement.bindText(1, value);
 133
 134     result = statement.step();
 135     if (result != SQLResultDone) {
 136         LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
 137         return false;
 138     }
 139
 140     return true;
 141 }
 142
 143 // FIXME: move all guid-related functions to a DatabaseVersionTracker class.
 144 static Mutex& guidMutex()
 145 {
 146     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
 147     return mutex;
 148 }
 149
 150 typedef HashMap<DatabaseGuid, String> GuidVersionMap;
 151 static GuidVersionMap& guidToVersionMap()
 152 {
 153     // Ensure the the mutex is locked.
 154     ASSERT(!guidMutex().tryLock());
 155     DEFINE_STATIC_LOCAL(GuidVersionMap, map, ());
 156     return map;
 157 }
 158
 159 // NOTE: Caller must lock guidMutex().
 160 static inline void updateGuidVersionMap(DatabaseGuid guid, String newVersion)
 161 {
 162     // Ensure the the mutex is locked.
 163     ASSERT(!guidMutex().tryLock());
 164
 165     // Note: It is not safe to put an empty string into the guidToVersionMap() map.
 166     // That's because the map is cross-thread, but empty strings are per-thread.
 167     // The copy() function makes a version of the string you can use on the current
 168     // thread, but we need a string we can keep in a cross-thread data structure.
 169     // FIXME: This is a quite-awkward restriction to have to program with.
 170
 171     // Map null string to empty string (see comment above).
 172     guidToVersionMap().set(guid, newVersion.isEmpty() ? String() : newVersion.isolatedCopy());
 173 }
 174
 175 typedef HashMap<DatabaseGuid, std::unique_ptr<HashSet<DatabaseBackendBase*>>> GuidDatabaseMap;
 176
 177 static GuidDatabaseMap& guidToDatabaseMap()
 178 {
 179     // Ensure the the mutex is locked.
 180     ASSERT(!guidMutex().tryLock());
 181     static NeverDestroyed<GuidDatabaseMap> map;
 182     return map;
 183 }
 184
 185 static DatabaseGuid guidForOriginAndName(const String& origin, const String& name)
 186 {
 187     // Ensure the the mutex is locked.
 188     ASSERT(!guidMutex().tryLock());
 189
 190     String stringID = origin + "/" + name;
 191
 192     typedef HashMap<String, int> IDGuidMap;
 193     static NeverDestroyed<HashMap<String, int>> map;
 194     DatabaseGuid guid = map.get().get(stringID);
 195     if (!guid) {
 196         static int currentNewGUID = 1;
 197         guid = currentNewGUID++;
 198         map.get().set(stringID, guid);
 199     }
 200
 201     return guid;
 202 }
 203
 204 // static
 205 const char* DatabaseBackendBase::databaseInfoTableName()
 206 {
 207     return infoTableName;
 208 }
 209
 210 #if !LOG_DISABLED || !ERROR_DISABLED
 211 String DatabaseBackendBase::databaseDebugName() const
 212 {
 213     return m_contextThreadSecurityOrigin->toString() + "::" + m_name;
 214 }
 215 #endif
 216
 217 DatabaseBackendBase::DatabaseBackendBase(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name,
 218     const String& expectedVersion, const String& displayName, unsigned long estimatedSize, DatabaseType databaseType)
 219     : m_databaseContext(databaseContext)
 220     , m_name(name.isolatedCopy())
 221     , m_expectedVersion(expectedVersion.isolatedCopy())
 222     , m_displayName(displayName.isolatedCopy())
 223     , m_estimatedSize(estimatedSize)
 224     , m_opened(false)
 225     , m_new(false)
 226     , m_isSyncDatabase(databaseType == DatabaseType::Sync)
 227 {
 228     m_contextThreadSecurityOrigin = m_databaseContext->securityOrigin()->isolatedCopy();
 229
 230     m_databaseAuthorizer = DatabaseAuthorizer::create(infoTableName);
 231
 232     if (m_name.isNull())
 233         m_name = emptyString();
 234
 235     {
 236         MutexLocker locker(guidMutex());
 237         m_guid = guidForOriginAndName(securityOrigin()->toString(), name);
 238         std::unique_ptr<HashSet<DatabaseBackendBase*>>& hashSet = guidToDatabaseMap().add(m_guid, nullptr).iterator->value;
 239         if (!hashSet)
 240             hashSet = std::make_unique<HashSet<DatabaseBackendBase*>>();
 241         hashSet->add(this);
 242     }
 243
 244     m_filename = DatabaseManager::manager().fullPathForDatabase(securityOrigin(), m_name);
 245 }
 246
 247 DatabaseBackendBase::~DatabaseBackendBase()
 248 {
 249     // SQLite is "multi-thread safe", but each database handle can only be used
 250     // on a single thread at a time.
 251     //
 252     // For DatabaseBackend, we open the SQLite database on the DatabaseThread,
 253     // and hence we should also close it on that same thread. This means that the
 254     // SQLite database need to be closed by another mechanism (see
 255     // DatabaseContext::stopDatabases()). By the time we get here, the SQLite
 256     // database should have already been closed.
 257
 258     ASSERT(!m_opened);
 259 }
 260
 261 void DatabaseBackendBase::closeDatabase()
 262 {
 263     if (!m_opened)
 264         return;
 265
 266     m_sqliteDatabase.close();
 267     m_opened = false;
 268     // See comment at the top this file regarding calling removeOpenDatabase().
 269     DatabaseTracker::tracker().removeOpenDatabase(this);
 270     {
 271         MutexLocker locker(guidMutex());
 272
 273         auto it = guidToDatabaseMap().find(m_guid);
 274         ASSERT(it != guidToDatabaseMap().end());
 275         ASSERT(it->value);
 276         ASSERT(it->value->contains(this));
 277         it->value->remove(this);
 278         if (it->value->isEmpty()) {
 279             guidToDatabaseMap().remove(it);
 280             guidToVersionMap().remove(m_guid);
 281         }
 282     }
 283 }
 284
 285 String DatabaseBackendBase::version() const
 286 {
 287     // Note: In multi-process browsers the cached value may be accurate, but we cannot read the
 288     // actual version from the database without potentially inducing a deadlock.
 289     // FIXME: Add an async version getter to the DatabaseAPI.
 290     return getCachedVersion();
 291 }
 292
 293 class DoneCreatingDatabaseOnExitCaller {
 294 public:
 295     DoneCreatingDatabaseOnExitCaller(DatabaseBackendBase* database)
 296         : m_database(database)
 297         , m_openSucceeded(false)
 298     {
 299     }
 300     ~DoneCreatingDatabaseOnExitCaller()
 301     {
 302         DatabaseTracker::tracker().doneCreatingDatabase(m_database);
 303     }
 304
 305     void setOpenSucceeded() { m_openSucceeded = true; }
 306
 307 private:
 308     DatabaseBackendBase* m_database;
 309     bool m_openSucceeded;
 310 };
 311
 312 bool DatabaseBackendBase::performOpenAndVerify(bool shouldSetVersionInNewDatabase, DatabaseError& error, String& errorMessage)
 313 {
 314     DoneCreatingDatabaseOnExitCaller onExitCaller(this);
 315     ASSERT(errorMessage.isEmpty());
 316     ASSERT(error == DatabaseError::None); // Better not have any errors already.
 317     error = DatabaseError::InvalidDatabaseState; // Presumed failure. We'll clear it if we succeed below.
 318
 319     const int maxSqliteBusyWaitTime = 30000;
 320
 321 #if PLATFORM(IOS)
 322     {
 323         // Make sure we wait till the background removal of the empty database files finished before trying to open any database.
 324         MutexLocker locker(DatabaseTracker::openDatabaseMutex());
 325     }
 326     SQLiteTransactionInProgressAutoCounter transactionCounter;
 327 #endif
 328
 329     if (!m_sqliteDatabase.open(m_filename, true)) {
 330         errorMessage = formatErrorMessage("unable to open database", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
 331         return false;
 332     }
 333     if (!m_sqliteDatabase.turnOnIncrementalAutoVacuum())
 334         LOG_ERROR("Unable to turn on incremental auto-vacuum (%d %s)", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
 335
 336     m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
 337
 338     String currentVersion;
 339     {
 340         MutexLocker locker(guidMutex());
 341
 342         auto entry = guidToVersionMap().find(m_guid);
 343         if (entry != guidToVersionMap().end()) {
 344             // Map null string to empty string (see updateGuidVersionMap()).
 345             currentVersion = entry->value.isNull() ? emptyString() : entry->value.isolatedCopy();
 346             LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
 347         } else {
 348             LOG(StorageAPI, "No cached version for guid %i", m_guid);
 349
 350             SQLiteTransaction transaction(m_sqliteDatabase);
 351             transaction.begin();
 352             if (!transaction.inProgress()) {
 353                 errorMessage = formatErrorMessage("unable to open database, failed to start transaction", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
 354                 m_sqliteDatabase.close();
 355                 return false;
 356             }
 357
 358             String tableName(infoTableName);
 359             if (!m_sqliteDatabase.tableExists(tableName)) {
 360                 m_new = true;
 361
 362                 if (!m_sqliteDatabase.executeCommand("CREATE TABLE " + tableName + " (key TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,value TEXT NOT NULL ON CONFLICT FAIL);")) {
 363                     errorMessage = formatErrorMessage("unable to open database, failed to create 'info' table", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
 364                     transaction.rollback();
 365                     m_sqliteDatabase.close();
 366                     return false;
 367                 }
 368             } else if (!getVersionFromDatabase(currentVersion, false)) {
 369                 errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
 370                 transaction.rollback();
 371                 m_sqliteDatabase.close();
 372                 return false;
 373             }
 374
 375             if (currentVersion.length()) {
 376                 LOG(StorageAPI, "Retrieved current version %s from database %s", currentVersion.ascii().data(), databaseDebugName().ascii().data());
 377             } else if (!m_new || shouldSetVersionInNewDatabase) {
 378                 LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
 379                 if (!setVersionInDatabase(m_expectedVersion, false)) {
 380                     errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
 381                     transaction.rollback();
 382                     m_sqliteDatabase.close();
 383                     return false;
 384                 }
 385                 currentVersion = m_expectedVersion;
 386             }
 387             updateGuidVersionMap(m_guid, currentVersion);
 388             transaction.commit();
 389         }
 390     }
 391
 392     if (currentVersion.isNull()) {
 393         LOG(StorageAPI, "Database %s does not have its version set", databaseDebugName().ascii().data());
 394         currentVersion = "";
 395     }
 396
 397     // If the expected version isn't the empty string, ensure that the current database version we have matches that version. Otherwise, set an exception.
 398     // If the expected version is the empty string, then we always return with whatever version of the database we have.
 399     if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
 400         errorMessage = "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'";
 401         m_sqliteDatabase.close();
 402         return false;
 403     }
 404
 405     ASSERT(m_databaseAuthorizer);
 406     m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer);
 407
 408     // See comment at the top this file regarding calling addOpenDatabase().
 409     DatabaseTracker::tracker().addOpenDatabase(this);
 410     m_opened = true;
 411
 412     // Declare success:
 413     error = DatabaseError::None; // Clear the presumed error from above.
 414     onExitCaller.setOpenSucceeded();
 415
 416     if (m_new && !shouldSetVersionInNewDatabase)
 417         m_expectedVersion = ""; // The caller provided a creationCallback which will set the expected version.
 418     return true;
 419 }
 420
 421 SecurityOrigin* DatabaseBackendBase::securityOrigin() const
 422 {
 423     return m_contextThreadSecurityOrigin.get();
 424 }
 425
 426 String DatabaseBackendBase::stringIdentifier() const
 427 {
 428     // Return a deep copy for ref counting thread safety
 429     return m_name.isolatedCopy();
 430 }
 431
 432 String DatabaseBackendBase::displayName() const
 433 {
 434     // Return a deep copy for ref counting thread safety
 435     return m_displayName.isolatedCopy();
 436 }
 437
 438 unsigned long DatabaseBackendBase::estimatedSize() const
 439 {
 440     return m_estimatedSize;
 441 }
 442
 443 String DatabaseBackendBase::fileName() const
 444 {
 445     // Return a deep copy for ref counting thread safety
 446     return m_filename.isolatedCopy();
 447 }
 448
 449 DatabaseDetails DatabaseBackendBase::details() const
 450 {
 451     return DatabaseDetails(stringIdentifier(), displayName(), estimatedSize(), 0);
 452 }
 453
 454 bool DatabaseBackendBase::getVersionFromDatabase(String& version, bool shouldCacheVersion)
 455 {
 456     String query(String("SELECT value FROM ") + infoTableName +  " WHERE key = '" + versionKey + "';");
 457
 458     m_databaseAuthorizer->disable();
 459
 460     bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, query, version);
 461     if (result) {
 462         if (shouldCacheVersion)
 463             setCachedVersion(version);
 464     } else
 465         LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
 466
 467     m_databaseAuthorizer->enable();
 468
 469     return result;
 470 }
 471
 472 bool DatabaseBackendBase::setVersionInDatabase(const String& version, bool shouldCacheVersion)
 473 {
 474     // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
 475     // clause in the CREATE statement (see Database::performOpenAndVerify()).
 476     String query(String("INSERT INTO ") + infoTableName +  " (key, value) VALUES ('" + versionKey + "', ?);");
 477
 478     m_databaseAuthorizer->disable();
 479
 480     bool result = setTextValueInDatabase(m_sqliteDatabase, query, version);
 481     if (result) {
 482         if (shouldCacheVersion)
 483             setCachedVersion(version);
 484     } else
 485         LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), query.ascii().data());
 486
 487     m_databaseAuthorizer->enable();
 488
 489     return result;
 490 }
 491
 492 void DatabaseBackendBase::setExpectedVersion(const String& version)
 493 {
 494     m_expectedVersion = version.isolatedCopy();
 495 }
 496
 497 String DatabaseBackendBase::getCachedVersion() const
 498 {
 499     MutexLocker locker(guidMutex());
 500     return guidToVersionMap().get(m_guid).isolatedCopy();
 501 }
 502
 503 void DatabaseBackendBase::setCachedVersion(const String& actualVersion)
 504 {
 505     // Update the in memory database version map.
 506     MutexLocker locker(guidMutex());
 507     updateGuidVersionMap(m_guid, actualVersion);
 508 }
 509
 510 bool DatabaseBackendBase::getActualVersionForTransaction(String &actualVersion)
 511 {
 512     ASSERT(m_sqliteDatabase.transactionInProgress());
 513     // Note: In multi-process browsers the cached value may be inaccurate.
 514     // So we retrieve the value from the database and update the cached value here.
 515     return getVersionFromDatabase(actualVersion, true);
 516 }
 517
 518 void DatabaseBackendBase::disableAuthorizer()
 519 {
 520     ASSERT(m_databaseAuthorizer);
 521     m_databaseAuthorizer->disable();
 522 }
 523
 524 void DatabaseBackendBase::enableAuthorizer()
 525 {
 526     ASSERT(m_databaseAuthorizer);
 527     m_databaseAuthorizer->enable();
 528 }
 529
 530 void DatabaseBackendBase::setAuthorizerReadOnly()
 531 {
 532     ASSERT(m_databaseAuthorizer);
 533     m_databaseAuthorizer->setReadOnly();
 534 }
 535
 536 void DatabaseBackendBase::setAuthorizerPermissions(int permissions)
 537 {
 538     ASSERT(m_databaseAuthorizer);
 539     m_databaseAuthorizer->setPermissions(permissions);
 540 }
 541
 542 bool DatabaseBackendBase::lastActionChangedDatabase()
 543 {
 544     ASSERT(m_databaseAuthorizer);
 545     return m_databaseAuthorizer->lastActionChangedDatabase();
 546 }
 547
 548 bool DatabaseBackendBase::lastActionWasInsert()
 549 {
 550     ASSERT(m_databaseAuthorizer);
 551     return m_databaseAuthorizer->lastActionWasInsert();
 552 }
 553
 554 void DatabaseBackendBase::resetDeletes()
 555 {
 556     ASSERT(m_databaseAuthorizer);
 557     m_databaseAuthorizer->resetDeletes();
 558 }
 559
 560 bool DatabaseBackendBase::hadDeletes()
 561 {
 562     ASSERT(m_databaseAuthorizer);
 563     return m_databaseAuthorizer->hadDeletes();
 564 }
 565
 566 void DatabaseBackendBase::resetAuthorizer()
 567 {
 568     if (m_databaseAuthorizer)
 569         m_databaseAuthorizer->reset();
 570 }
 571
 572 unsigned long long DatabaseBackendBase::maximumSize() const
 573 {
 574     return DatabaseTracker::tracker().getMaxSizeForDatabase(this);
 575 }
 576
 577 void DatabaseBackendBase::incrementalVacuumIfNeeded()
 578 {
 579 #if PLATFORM(IOS)
 580     SQLiteTransactionInProgressAutoCounter transactionCounter;
 581 #endif
 582     int64_t freeSpaceSize = m_sqliteDatabase.freeSpaceSize();
 583     int64_t totalSize = m_sqliteDatabase.totalSize();
 584     if (totalSize <= 10 * freeSpaceSize) {
 585         int result = m_sqliteDatabase.runIncrementalVacuumCommand();
 586         if (result != SQLResultOk)
 587             m_frontend->logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
 588     }
 589 }
 590
 591 void DatabaseBackendBase::interrupt()
 592 {
 593     m_sqliteDatabase.interrupt();
 594 }
 595
 596 bool DatabaseBackendBase::isInterrupted()
 597 {
 598     MutexLocker locker(m_sqliteDatabase.databaseMutex());
 599     return m_sqliteDatabase.isInterrupted();
 600 }
 601
 602 } // namespace WebCore
 603
 604 #endif // ENABLE(SQL_DATABASE)