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