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