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