Initial refactoring of database functionality into the manager and server.
[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 "DatabaseManager.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<DatabaseGuid, 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(DatabaseGuid 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<DatabaseGuid, 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 DatabaseGuid 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     DatabaseGuid 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
172 const char* AbstractDatabase::databaseInfoTableName()
173 {
174     return infoTableName;
175 }
176
177 AbstractDatabase::AbstractDatabase(ScriptExecutionContext* context, const String& name, const String& expectedVersion,
178                                    const String& displayName, unsigned long estimatedSize, DatabaseType databaseType)
179     : m_scriptExecutionContext(context)
180     , m_databaseContext(DatabaseContext::from(context))
181     , m_name(name.isolatedCopy())
182     , m_expectedVersion(expectedVersion.isolatedCopy())
183     , m_displayName(displayName.isolatedCopy())
184     , m_estimatedSize(estimatedSize)
185     , m_guid(0)
186     , m_opened(false)
187     , m_new(false)
188     , m_isSyncDatabase(databaseType == SyncDatabase)
189 {
190     ASSERT(context->isContextThread());
191     m_contextThreadSecurityOrigin = m_scriptExecutionContext->securityOrigin();
192
193     m_databaseAuthorizer = DatabaseAuthorizer::create(infoTableName);
194
195     if (m_name.isNull())
196         m_name = "";
197
198     {
199         MutexLocker locker(guidMutex());
200         m_guid = guidForOriginAndName(securityOrigin()->toString(), name);
201         HashSet<AbstractDatabase*>* hashSet = guidToDatabaseMap().get(m_guid);
202         if (!hashSet) {
203             hashSet = new HashSet<AbstractDatabase*>;
204             guidToDatabaseMap().set(m_guid, hashSet);
205         }
206
207         hashSet->add(this);
208     }
209
210     m_filename = DatabaseManager::manager().fullPathForDatabase(securityOrigin(), m_name);
211     DatabaseManager::manager().addOpenDatabase(this);
212 }
213
214 AbstractDatabase::~AbstractDatabase()
215 {
216     ASSERT(!m_opened);
217 }
218
219 void AbstractDatabase::closeDatabase()
220 {
221     if (!m_opened)
222         return;
223
224     m_sqliteDatabase.close();
225     m_opened = false;
226     {
227         MutexLocker locker(guidMutex());
228
229         HashSet<AbstractDatabase*>* hashSet = guidToDatabaseMap().get(m_guid);
230         ASSERT(hashSet);
231         ASSERT(hashSet->contains(this));
232         hashSet->remove(this);
233         if (hashSet->isEmpty()) {
234             guidToDatabaseMap().remove(m_guid);
235             delete hashSet;
236             guidToVersionMap().remove(m_guid);
237         }
238     }
239 }
240
241 String AbstractDatabase::version() const
242 {
243     // Note: In multi-process browsers the cached value may be accurate, but we cannot read the
244     // actual version from the database without potentially inducing a deadlock.
245     // FIXME: Add an async version getter to the DatabaseAPI.
246     return getCachedVersion();
247 }
248
249 bool AbstractDatabase::performOpenAndVerify(bool shouldSetVersionInNewDatabase, ExceptionCode& ec, String& errorMessage)
250 {
251     ASSERT(errorMessage.isEmpty());
252
253     const int maxSqliteBusyWaitTime = 30000;
254
255     if (!m_sqliteDatabase.open(m_filename, true)) {
256         reportOpenDatabaseResult(1, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
257         errorMessage = formatErrorMessage("unable to open database", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
258         ec = INVALID_STATE_ERR;
259         return false;
260     }
261     if (!m_sqliteDatabase.turnOnIncrementalAutoVacuum())
262         LOG_ERROR("Unable to turn on incremental auto-vacuum (%d %s)", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
263
264     m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
265
266     String currentVersion;
267     {
268         MutexLocker locker(guidMutex());
269
270         GuidVersionMap::iterator entry = guidToVersionMap().find(m_guid);
271         if (entry != guidToVersionMap().end()) {
272             // Map null string to empty string (see updateGuidVersionMap()).
273             currentVersion = entry->value.isNull() ? emptyString() : entry->value.isolatedCopy();
274             LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
275
276 #if PLATFORM(CHROMIUM)
277             // Note: In multi-process browsers the cached value may be inaccurate, but
278             // we cannot read the actual version from the database without potentially
279             // inducing a form of deadlock, a busytimeout error when trying to
280             // access the database. So we'll use the cached value if we're unable to read
281             // the value from the database file without waiting.
282             // FIXME: Add an async openDatabase method to the DatabaseAPI.
283             const int noSqliteBusyWaitTime = 0;
284             m_sqliteDatabase.setBusyTimeout(noSqliteBusyWaitTime);
285             String versionFromDatabase;
286             if (getVersionFromDatabase(versionFromDatabase, false)) {
287                 currentVersion = versionFromDatabase;
288                 updateGuidVersionMap(m_guid, currentVersion);
289             }
290             m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
291 #endif
292         } else {
293             LOG(StorageAPI, "No cached version for guid %i", m_guid);
294
295             SQLiteTransaction transaction(m_sqliteDatabase);
296             transaction.begin();
297             if (!transaction.inProgress()) {
298                 reportOpenDatabaseResult(2, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
299                 errorMessage = formatErrorMessage("unable to open database, failed to start transaction", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
300                 ec = INVALID_STATE_ERR;
301                 m_sqliteDatabase.close();
302                 return false;
303             }
304
305             String tableName(infoTableName);
306             if (!m_sqliteDatabase.tableExists(tableName)) {
307                 m_new = true;
308
309                 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);")) {
310                     reportOpenDatabaseResult(3, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
311                     errorMessage = formatErrorMessage("unable to open database, failed to create 'info' table", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
312                     ec = INVALID_STATE_ERR;
313                     transaction.rollback();
314                     m_sqliteDatabase.close();
315                     return false;
316                 }
317             } else if (!getVersionFromDatabase(currentVersion, false)) {
318                 reportOpenDatabaseResult(4, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
319                 errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
320                 ec = INVALID_STATE_ERR;
321                 transaction.rollback();
322                 m_sqliteDatabase.close();
323                 return false;
324             }
325
326             if (currentVersion.length()) {
327                 LOG(StorageAPI, "Retrieved current version %s from database %s", currentVersion.ascii().data(), databaseDebugName().ascii().data());
328             } else if (!m_new || shouldSetVersionInNewDatabase) {
329                 LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
330                 if (!setVersionInDatabase(m_expectedVersion, false)) {
331                     reportOpenDatabaseResult(5, INVALID_STATE_ERR, m_sqliteDatabase.lastError());
332                     errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
333                     ec = INVALID_STATE_ERR;
334                     transaction.rollback();
335                     m_sqliteDatabase.close();
336                     return false;
337                 }
338                 currentVersion = m_expectedVersion;
339             }
340             updateGuidVersionMap(m_guid, currentVersion);
341             transaction.commit();
342         }
343     }
344
345     if (currentVersion.isNull()) {
346         LOG(StorageAPI, "Database %s does not have its version set", databaseDebugName().ascii().data());
347         currentVersion = "";
348     }
349
350     // If the expected version isn't the empty string, ensure that the current database version we have matches that version. Otherwise, set an exception.
351     // If the expected version is the empty string, then we always return with whatever version of the database we have.
352     if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
353         reportOpenDatabaseResult(6, INVALID_STATE_ERR, 0);
354         errorMessage = "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'";
355         ec = INVALID_STATE_ERR;
356         m_sqliteDatabase.close();
357         return false;
358     }
359
360     ASSERT(m_databaseAuthorizer);
361     m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer);
362
363     m_opened = true;
364
365     if (m_new && !shouldSetVersionInNewDatabase)
366         m_expectedVersion = ""; // The caller provided a creationCallback which will set the expected version.
367
368     reportOpenDatabaseResult(0, -1, 0); // OK
369     return true;
370 }
371
372 ScriptExecutionContext* AbstractDatabase::scriptExecutionContext() const
373 {
374     return m_scriptExecutionContext.get();
375 }
376
377 SecurityOrigin* AbstractDatabase::securityOrigin() const
378 {
379     return m_contextThreadSecurityOrigin.get();
380 }
381
382 String AbstractDatabase::stringIdentifier() const
383 {
384     // Return a deep copy for ref counting thread safety
385     return m_name.isolatedCopy();
386 }
387
388 String AbstractDatabase::displayName() const
389 {
390     // Return a deep copy for ref counting thread safety
391     return m_displayName.isolatedCopy();
392 }
393
394 unsigned long AbstractDatabase::estimatedSize() const
395 {
396     return m_estimatedSize;
397 }
398
399 String AbstractDatabase::fileName() const
400 {
401     // Return a deep copy for ref counting thread safety
402     return m_filename.isolatedCopy();
403 }
404
405 bool AbstractDatabase::getVersionFromDatabase(String& version, bool shouldCacheVersion)
406 {
407     String query(String("SELECT value FROM ") + infoTableName +  " WHERE key = '" + versionKey + "';");
408
409     m_databaseAuthorizer->disable();
410
411     bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, query, version);
412     if (result) {
413         if (shouldCacheVersion)
414             setCachedVersion(version);
415     } else
416         LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
417
418     m_databaseAuthorizer->enable();
419
420     return result;
421 }
422
423 bool AbstractDatabase::setVersionInDatabase(const String& version, bool shouldCacheVersion)
424 {
425     // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
426     // clause in the CREATE statement (see Database::performOpenAndVerify()).
427     String query(String("INSERT INTO ") + infoTableName +  " (key, value) VALUES ('" + versionKey + "', ?);");
428
429     m_databaseAuthorizer->disable();
430
431     bool result = setTextValueInDatabase(m_sqliteDatabase, query, version);
432     if (result) {
433         if (shouldCacheVersion)
434             setCachedVersion(version);
435     } else
436         LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), query.ascii().data());
437
438     m_databaseAuthorizer->enable();
439
440     return result;
441 }
442
443 void AbstractDatabase::setExpectedVersion(const String& version)
444 {
445     m_expectedVersion = version.isolatedCopy();
446 }
447
448 String AbstractDatabase::getCachedVersion() const
449 {
450     MutexLocker locker(guidMutex());
451     return guidToVersionMap().get(m_guid).isolatedCopy();
452 }
453
454 void AbstractDatabase::setCachedVersion(const String& actualVersion)
455 {
456     // Update the in memory database version map.
457     MutexLocker locker(guidMutex());
458     updateGuidVersionMap(m_guid, actualVersion);
459 }
460
461 bool AbstractDatabase::getActualVersionForTransaction(String &actualVersion)
462 {
463     ASSERT(m_sqliteDatabase.transactionInProgress());
464 #if PLATFORM(CHROMIUM)
465     // Note: In multi-process browsers the cached value may be inaccurate.
466     // So we retrieve the value from the database and update the cached value here.
467     return getVersionFromDatabase(actualVersion, true);
468 #else
469     actualVersion = getCachedVersion();
470     return true;
471 #endif
472 }
473
474 void AbstractDatabase::disableAuthorizer()
475 {
476     ASSERT(m_databaseAuthorizer);
477     m_databaseAuthorizer->disable();
478 }
479
480 void AbstractDatabase::enableAuthorizer()
481 {
482     ASSERT(m_databaseAuthorizer);
483     m_databaseAuthorizer->enable();
484 }
485
486 void AbstractDatabase::setAuthorizerReadOnly()
487 {
488     ASSERT(m_databaseAuthorizer);
489     m_databaseAuthorizer->setReadOnly();
490 }
491
492 void AbstractDatabase::setAuthorizerPermissions(int permissions)
493 {
494     ASSERT(m_databaseAuthorizer);
495     m_databaseAuthorizer->setPermissions(permissions);
496 }
497
498 bool AbstractDatabase::lastActionChangedDatabase()
499 {
500     ASSERT(m_databaseAuthorizer);
501     return m_databaseAuthorizer->lastActionChangedDatabase();
502 }
503
504 bool AbstractDatabase::lastActionWasInsert()
505 {
506     ASSERT(m_databaseAuthorizer);
507     return m_databaseAuthorizer->lastActionWasInsert();
508 }
509
510 void AbstractDatabase::resetDeletes()
511 {
512     ASSERT(m_databaseAuthorizer);
513     m_databaseAuthorizer->resetDeletes();
514 }
515
516 bool AbstractDatabase::hadDeletes()
517 {
518     ASSERT(m_databaseAuthorizer);
519     return m_databaseAuthorizer->hadDeletes();
520 }
521
522 void AbstractDatabase::resetAuthorizer()
523 {
524     if (m_databaseAuthorizer)
525         m_databaseAuthorizer->reset();
526 }
527
528 unsigned long long AbstractDatabase::maximumSize() const
529 {
530     return DatabaseManager::manager().getMaxSizeForDatabase(this);
531 }
532
533 void AbstractDatabase::incrementalVacuumIfNeeded()
534 {
535     int64_t freeSpaceSize = m_sqliteDatabase.freeSpaceSize();
536     int64_t totalSize = m_sqliteDatabase.totalSize();
537     if (totalSize <= 10 * freeSpaceSize) {
538         int result = m_sqliteDatabase.runIncrementalVacuumCommand();
539         reportVacuumDatabaseResult(result);
540         if (result != SQLResultOk)
541             logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
542     }
543 }
544
545 void AbstractDatabase::interrupt()
546 {
547     m_sqliteDatabase.interrupt();
548 }
549
550 bool AbstractDatabase::isInterrupted()
551 {
552     MutexLocker locker(m_sqliteDatabase.databaseMutex());
553     return m_sqliteDatabase.isInterrupted();
554 }
555
556 void AbstractDatabase::logErrorMessage(const String& message)
557 {
558     m_scriptExecutionContext->addConsoleMessage(OtherMessageSource, ErrorMessageLevel, message);
559 }
560
561 #if PLATFORM(CHROMIUM)
562 // These are used to generate histograms of errors seen with websql.
563 // See about:histograms in chromium.
564 void AbstractDatabase::reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
565 {
566     DatabaseObserver::reportOpenDatabaseResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
567 }
568
569 void AbstractDatabase::reportChangeVersionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
570 {
571     DatabaseObserver::reportChangeVersionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
572 }
573
574 void AbstractDatabase::reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
575 {
576     DatabaseObserver::reportStartTransactionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
577 }
578
579 void AbstractDatabase::reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
580 {
581     DatabaseObserver::reportCommitTransactionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
582 }
583
584 void AbstractDatabase::reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
585 {
586     DatabaseObserver::reportExecuteStatementResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
587 }
588
589 void AbstractDatabase::reportVacuumDatabaseResult(int sqliteErrorCode)
590 {
591     DatabaseObserver::reportVacuumDatabaseResult(this, sqliteErrorCode);
592 }
593
594 #else
595 void AbstractDatabase::reportOpenDatabaseResult(int, int, int) { }
596 void AbstractDatabase::reportChangeVersionResult(int, int, int) { }
597 void AbstractDatabase::reportStartTransactionResult(int, int, int) { }
598 void AbstractDatabase::reportCommitTransactionResult(int, int, int) { }
599 void AbstractDatabase::reportExecuteStatementResult(int, int, int) { }
600 void AbstractDatabase::reportVacuumDatabaseResult(int) { }
601 #endif // PLATFORM(CHROMIUM)
602
603 } // namespace WebCore
604
605 #endif // ENABLE(SQL_DATABASE)