aca66b057a285ea1e2b30bd1a351ebfcda23dd75
[WebKit-https.git] / WebCore / storage / Database.cpp
1 /*
2  * Copyright (C) 2007, 2008 Apple 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 "Database.h"
31
32 #include <wtf/StdLibExtras.h>
33
34 #if ENABLE(DATABASE)
35 #include "ChangeVersionWrapper.h"
36 #include "CString.h"
37 #include "DatabaseAuthorizer.h"
38 #include "DatabaseTask.h"
39 #include "DatabaseThread.h"
40 #include "DatabaseTracker.h"
41 #include "Document.h"
42 #include "ExceptionCode.h"
43 #include "Frame.h"
44 #include "InspectorController.h"
45 #include "Logging.h"
46 #include "NotImplemented.h"
47 #include "Page.h"
48 #include "OriginQuotaManager.h"
49 #include "ScriptController.h"
50 #include "SQLiteDatabase.h"
51 #include "SQLiteFileSystem.h"
52 #include "SQLiteStatement.h"
53 #include "SQLResultSet.h"
54 #include "SQLTransactionClient.h"
55 #include "SQLTransactionCoordinator.h"
56 #include <wtf/MainThread.h>
57 #endif
58
59 #if USE(JSC)
60 #include "JSDOMWindow.h"
61 #endif
62
63 namespace WebCore {
64
65 // If we sleep for more the 30 seconds while blocked on SQLITE_BUSY, give up.
66 static const int maxSqliteBusyWaitTime = 30000;
67
68 const String& Database::databaseInfoTableName()
69 {
70     DEFINE_STATIC_LOCAL(String, name, ("__WebKitDatabaseInfoTable__"));
71     return name;
72 }
73
74 #if ENABLE(DATABASE)
75
76 static Mutex& guidMutex()
77 {
78     // Note: We don't have to use AtomicallyInitializedStatic here because
79     // this function is called once in the constructor on the main thread
80     // before any other threads that call this function are used.
81     DEFINE_STATIC_LOCAL(Mutex, mutex, ());
82     return mutex;
83 }
84
85 typedef HashMap<int, String> GuidVersionMap;
86 static GuidVersionMap& guidToVersionMap()
87 {
88     DEFINE_STATIC_LOCAL(GuidVersionMap, map, ());
89     return map;
90 }
91
92 // NOTE: Caller must lock guidMutex().
93 static inline void updateGuidVersionMap(int guid, String newVersion)
94 {
95     // Ensure the the mutex is locked.
96     ASSERT(!guidMutex().tryLock());
97
98     // Note: It is not safe to put an empty string into the guidToVersionMap() map.
99     // That's because the map is cross-thread, but empty strings are per-thread.
100     // The copy() function makes a version of the string you can use on the current
101     // thread, but we need a string we can keep in a cross-thread data structure.
102     // FIXME: This is a quite-awkward restriction to have to program with.
103
104     // Map null string to empty string (see comment above).
105     guidToVersionMap().set(guid, newVersion.isEmpty() ? String() : newVersion.threadsafeCopy());
106 }
107
108 typedef HashMap<int, HashSet<Database*>*> GuidDatabaseMap;
109 static GuidDatabaseMap& guidToDatabaseMap()
110 {
111     DEFINE_STATIC_LOCAL(GuidDatabaseMap, map, ());
112     return map;
113 }
114
115 static const String& databaseVersionKey()
116 {
117     DEFINE_STATIC_LOCAL(String, key, ("WebKitDatabaseVersionKey"));
118     return key;
119 }
120
121 static int guidForOriginAndName(const String& origin, const String& name);
122
123 PassRefPtr<Database> Database::openDatabase(Document* document, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, ExceptionCode& e)
124 {
125     if (!DatabaseTracker::tracker().canEstablishDatabase(document, name, displayName, estimatedSize)) {
126         // FIXME: There should be an exception raised here in addition to returning a null Database object.  The question has been raised with the WHATWG.
127         LOG(StorageAPI, "Database %s for origin %s not allowed to be established", name.ascii().data(), document->securityOrigin()->toString().ascii().data());
128         return 0;
129     }
130
131     RefPtr<Database> database = adoptRef(new Database(document, name, expectedVersion, displayName, estimatedSize));
132
133     if (!database->openAndVerifyVersion(e)) {
134        LOG(StorageAPI, "Failed to open and verify version (expected %s) of database %s", expectedVersion.ascii().data(), database->databaseDebugName().ascii().data());
135        return 0;
136     }
137
138     DatabaseTracker::tracker().addOpenDatabase(database.get());
139     document->addOpenDatabase(database.get());
140
141     DatabaseTracker::tracker().setDatabaseDetails(document->securityOrigin(), name, displayName, estimatedSize);
142
143     document->setHasOpenDatabases();
144
145 #if ENABLE(INSPECTOR)
146     if (Page* page = document->frame()->page())
147         page->inspectorController()->didOpenDatabase(database.get(), document->securityOrigin()->host(), name, expectedVersion);
148 #endif
149
150     return database;
151 }
152
153 Database::Database(Document* document, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
154     : m_transactionInProgress(false)
155     , m_isTransactionQueueEnabled(true)
156     , m_document(document)
157     , m_name(name.crossThreadString())
158     , m_guid(0)
159     , m_expectedVersion(expectedVersion.crossThreadString())
160     , m_displayName(displayName.crossThreadString())
161     , m_estimatedSize(estimatedSize)
162     , m_deleted(false)
163     , m_stopped(false)
164     , m_opened(false)
165 {
166     ASSERT(document);
167     m_mainThreadSecurityOrigin = document->securityOrigin();
168     m_databaseThreadSecurityOrigin = m_mainThreadSecurityOrigin->threadsafeCopy();
169
170     if (m_name.isNull())
171         m_name = "";
172
173     ScriptController::initializeThreading();
174
175     m_guid = guidForOriginAndName(m_mainThreadSecurityOrigin->toString(), name);
176
177     {
178         MutexLocker locker(guidMutex());
179
180         HashSet<Database*>* hashSet = guidToDatabaseMap().get(m_guid);
181         if (!hashSet) {
182             hashSet = new HashSet<Database*>;
183             guidToDatabaseMap().set(m_guid, hashSet);
184         }
185
186         hashSet->add(this);
187     }
188
189     ASSERT(m_document->databaseThread());
190
191     m_filename = DatabaseTracker::tracker().fullPathForDatabase(m_mainThreadSecurityOrigin.get(), m_name);
192 }
193
194 static void derefDocument(void* document)
195 {
196     static_cast<Document*>(document)->deref();
197 }
198
199 Database::~Database()
200 {
201     // Deref m_document on the main thread.
202     callOnMainThread(derefDocument, m_document.release().releaseRef());
203 }
204
205 bool Database::openAndVerifyVersion(ExceptionCode& e)
206 {
207     if (!m_document->databaseThread())
208         return false;
209     m_databaseAuthorizer = DatabaseAuthorizer::create();
210
211     bool success = false;
212     DatabaseTaskSynchronizer synchronizer;
213     OwnPtr<DatabaseOpenTask> task = DatabaseOpenTask::create(this, &synchronizer, e, success);
214
215     m_document->databaseThread()->scheduleImmediateTask(task.release());
216     synchronizer.waitForTaskCompletion();
217
218     return success;
219 }
220
221
222 static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& query, String& resultString)
223 {
224     SQLiteStatement statement(db, query);
225     int result = statement.prepare();
226
227     if (result != SQLResultOk) {
228         LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
229         return false;
230     }
231
232     result = statement.step();
233     if (result == SQLResultRow) {
234         resultString = statement.getColumnText(0);
235         return true;
236     } else if (result == SQLResultDone) {
237         resultString = String();
238         return true;
239     } else {
240         LOG_ERROR("Error (%i) reading text result from database (%s)", result, query.ascii().data());
241         return false;
242     }
243 }
244
245 bool Database::getVersionFromDatabase(String& version)
246 {
247     DEFINE_STATIC_LOCAL(String, getVersionQuery, ("SELECT value FROM " + databaseInfoTableName() + " WHERE key = '" + databaseVersionKey() + "';"));
248
249     m_databaseAuthorizer->disable();
250
251     bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, getVersionQuery.threadsafeCopy(), version);
252     if (!result)
253         LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
254
255     m_databaseAuthorizer->enable();
256
257     return result;
258 }
259
260 static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, const String& value)
261 {
262     SQLiteStatement statement(db, query);
263     int result = statement.prepare();
264
265     if (result != SQLResultOk) {
266         LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
267         return false;
268     }
269
270     statement.bindText(1, value);
271
272     result = statement.step();
273     if (result != SQLResultDone) {
274         LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
275         return false;
276     }
277
278     return true;
279 }
280
281 bool Database::setVersionInDatabase(const String& version)
282 {
283     // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
284     // clause in the CREATE statement (see Database::performOpenAndVerify()).
285     DEFINE_STATIC_LOCAL(String, setVersionQuery, ("INSERT INTO " + databaseInfoTableName() + " (key, value) VALUES ('" + databaseVersionKey() + "', ?);"));
286
287     m_databaseAuthorizer->disable();
288
289     bool result = setTextValueInDatabase(m_sqliteDatabase, setVersionQuery.threadsafeCopy(), version);
290     if (!result)
291         LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), setVersionQuery.ascii().data());
292
293     m_databaseAuthorizer->enable();
294
295     return result;
296 }
297
298 bool Database::versionMatchesExpected() const
299 {
300     if (!m_expectedVersion.isEmpty()) {
301         MutexLocker locker(guidMutex());
302         return m_expectedVersion == guidToVersionMap().get(m_guid);
303     }
304
305     return true;
306 }
307
308 void Database::markAsDeletedAndClose()
309 {
310     if (m_deleted || !m_document->databaseThread())
311         return;
312
313     LOG(StorageAPI, "Marking %s (%p) as deleted", stringIdentifier().ascii().data(), this);
314     m_deleted = true;
315
316     if (m_document->databaseThread()->terminationRequested()) {
317         LOG(StorageAPI, "Database handle %p is on a terminated DatabaseThread, cannot be marked for normal closure\n", this);
318         return;
319     }
320
321     m_document->databaseThread()->unscheduleDatabaseTasks(this);
322
323     DatabaseTaskSynchronizer synchronizer;
324     OwnPtr<DatabaseCloseTask> task = DatabaseCloseTask::create(this, &synchronizer);
325
326     m_document->databaseThread()->scheduleImmediateTask(task.release());
327     synchronizer.waitForTaskCompletion();
328 }
329
330 static void documentRemoveOpenDatabase(void* context)
331 {
332     ASSERT(isMainThread());
333     Database* database = static_cast<Database*>(context);
334     database->document()->removeOpenDatabase(database);
335     database->deref();
336 }
337
338 void Database::close()
339 {
340     if (!m_opened)
341         return;
342
343     ASSERT(m_document->databaseThread());
344     ASSERT(currentThread() == document()->databaseThread()->getThreadID());
345     m_sqliteDatabase.close();
346     m_document->databaseThread()->recordDatabaseClosed(this);
347     m_opened = false;
348
349     {
350         MutexLocker locker(guidMutex());
351
352         HashSet<Database*>* hashSet = guidToDatabaseMap().get(m_guid);
353         ASSERT(hashSet);
354         ASSERT(hashSet->contains(this));
355         hashSet->remove(this);
356         if (hashSet->isEmpty()) {
357             guidToDatabaseMap().remove(m_guid);
358             delete hashSet;
359             guidToVersionMap().remove(m_guid);
360         }
361     }
362
363     m_document->databaseThread()->unscheduleDatabaseTasks(this);
364
365     DatabaseTracker::tracker().removeOpenDatabase(this);
366     ref();  // deref() called in documentRemoveOpenDatabase()
367     callOnMainThread(documentRemoveOpenDatabase, this);
368 }
369
370 void Database::stop()
371 {
372     // FIXME: The net effect of the following code is to remove all pending transactions and statements, but allow the current statement
373     // to run to completion.  In the future we can use the sqlite3_progress_handler or sqlite3_interrupt interfaces to cancel the current
374     // statement in response to close(), as well.
375
376     // This method is meant to be used as an analog to cancelling a loader, and is used when a document is shut down as the result of
377     // a page load or closing the page
378     m_stopped = true;
379
380     {
381         MutexLocker locker(m_transactionInProgressMutex);
382         m_isTransactionQueueEnabled = false;
383         m_transactionInProgress = false;
384     }
385 }
386
387 unsigned long long Database::maximumSize() const
388 {
389     return DatabaseTracker::tracker().getMaxSizeForDatabase(this);
390 }
391
392 void Database::disableAuthorizer()
393 {
394     ASSERT(m_databaseAuthorizer);
395     m_databaseAuthorizer->disable();
396 }
397
398 void Database::enableAuthorizer()
399 {
400     ASSERT(m_databaseAuthorizer);
401     m_databaseAuthorizer->enable();
402 }
403
404 void Database::setAuthorizerReadOnly()
405 {
406     ASSERT(m_databaseAuthorizer);
407     m_databaseAuthorizer->setReadOnly();
408 }
409
410 static int guidForOriginAndName(const String& origin, const String& name)
411 {
412     String stringID;
413     if (origin.endsWith("/"))
414         stringID = origin + name;
415     else
416         stringID = origin + "/" + name;
417
418     // Note: We don't have to use AtomicallyInitializedStatic here because
419     // this function is called once in the constructor on the main thread
420     // before any other threads that call this function are used.
421     DEFINE_STATIC_LOCAL(Mutex, stringIdentifierMutex, ());
422     MutexLocker locker(stringIdentifierMutex);
423     typedef HashMap<String, int> IDGuidMap;
424     DEFINE_STATIC_LOCAL(IDGuidMap, stringIdentifierToGUIDMap, ());
425     int guid = stringIdentifierToGUIDMap.get(stringID);
426     if (!guid) {
427         static int currentNewGUID = 1;
428         guid = currentNewGUID++;
429         stringIdentifierToGUIDMap.set(stringID, guid);
430     }
431
432     return guid;
433 }
434
435 void Database::resetAuthorizer()
436 {
437     if (m_databaseAuthorizer)
438         m_databaseAuthorizer->reset();
439 }
440
441 void Database::performPolicyChecks()
442 {
443     // FIXME: Code similar to the following will need to be run to enforce the per-origin size limit the spec mandates.
444     // Additionally, we might need a way to pause the database thread while the UA prompts the user for permission to
445     // increase the size limit
446
447     /*
448     if (m_databaseAuthorizer->lastActionIncreasedSize())
449         DatabaseTracker::scheduleFileSizeCheckOnMainThread(this);
450     */
451
452     notImplemented();
453 }
454
455 bool Database::performOpenAndVerify(ExceptionCode& e)
456 {
457     if (!m_sqliteDatabase.open(m_filename)) {
458         LOG_ERROR("Unable to open database at path %s", m_filename.ascii().data());
459         e = INVALID_STATE_ERR;
460         return false;
461     }
462
463     ASSERT(m_databaseAuthorizer);
464     m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer);
465     m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
466
467     String currentVersion;
468     {
469         MutexLocker locker(guidMutex());
470
471         GuidVersionMap::iterator entry = guidToVersionMap().find(m_guid);
472         if (entry != guidToVersionMap().end()) {
473             // Map null string to empty string (see updateGuidVersionMap()).
474             currentVersion = entry->second.isNull() ? String("") : entry->second;
475             LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
476         } else {
477             LOG(StorageAPI, "No cached version for guid %i", m_guid);
478
479             if (!m_sqliteDatabase.tableExists(databaseInfoTableName())) {
480                 if (!m_sqliteDatabase.executeCommand("CREATE TABLE " + databaseInfoTableName() + " (key TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,value TEXT NOT NULL ON CONFLICT FAIL);")) {
481                     LOG_ERROR("Unable to create table %s in database %s", databaseInfoTableName().ascii().data(), databaseDebugName().ascii().data());
482                     e = INVALID_STATE_ERR;
483                     return false;
484                 }
485             }
486
487             if (!getVersionFromDatabase(currentVersion)) {
488                 LOG_ERROR("Failed to get current version from database %s", databaseDebugName().ascii().data());
489                 e = INVALID_STATE_ERR;
490                 return false;
491             }
492             if (currentVersion.length()) {
493                 LOG(StorageAPI, "Retrieved current version %s from database %s", currentVersion.ascii().data(), databaseDebugName().ascii().data());
494             } else {
495                 LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
496                 if (!setVersionInDatabase(m_expectedVersion)) {
497                     LOG_ERROR("Failed to set version %s in database %s", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
498                     e = INVALID_STATE_ERR;
499                     return false;
500                 }
501                 currentVersion = m_expectedVersion;
502             }
503
504             updateGuidVersionMap(m_guid, currentVersion);
505         }
506     }
507
508     if (currentVersion.isNull()) {
509         LOG(StorageAPI, "Database %s does not have its version set", databaseDebugName().ascii().data());
510         currentVersion = "";
511     }
512
513     // If the expected version isn't the empty string, ensure that the current database version we have matches that version. Otherwise, set an exception.
514     // If the expected version is the empty string, then we always return with whatever version of the database we have.
515     if (m_expectedVersion.length() && m_expectedVersion != currentVersion) {
516         LOG(StorageAPI, "page expects version %s from database %s, which actually has version name %s - openDatabase() call will fail", m_expectedVersion.ascii().data(),
517             databaseDebugName().ascii().data(), currentVersion.ascii().data());
518         e = INVALID_STATE_ERR;
519         return false;
520     }
521
522     m_opened = true;
523     if (m_document->databaseThread())
524         m_document->databaseThread()->recordDatabaseOpen(this);
525
526     return true;
527 }
528
529 void Database::changeVersion(const String& oldVersion, const String& newVersion,
530                              PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
531                              PassRefPtr<VoidCallback> successCallback)
532 {
533     m_transactionQueue.append(SQLTransaction::create(this, callback, errorCallback, successCallback, ChangeVersionWrapper::create(oldVersion, newVersion)));
534     MutexLocker locker(m_transactionInProgressMutex);
535     if (!m_transactionInProgress)
536         scheduleTransaction();
537 }
538
539 void Database::transaction(PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
540                            PassRefPtr<VoidCallback> successCallback, bool readOnly)
541 {
542     m_transactionQueue.append(SQLTransaction::create(this, callback, errorCallback, successCallback, 0, readOnly));
543     MutexLocker locker(m_transactionInProgressMutex);
544     if (!m_transactionInProgress)
545         scheduleTransaction();
546 }
547
548 void Database::scheduleTransaction()
549 {
550     ASSERT(!m_transactionInProgressMutex.tryLock()); // Locked by caller.
551     RefPtr<SQLTransaction> transaction;
552
553     if (m_isTransactionQueueEnabled && !m_transactionQueue.isEmpty()) {
554         transaction = m_transactionQueue.first();
555         m_transactionQueue.removeFirst();
556     }
557
558     if (transaction && m_document->databaseThread()) {
559         OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
560         LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
561         m_transactionInProgress = true;
562         m_document->databaseThread()->scheduleTask(task.release());
563     } else
564         m_transactionInProgress = false;
565 }
566
567 void Database::scheduleTransactionStep(SQLTransaction* transaction, bool immediately)
568 {
569     if (!m_document->databaseThread())
570         return;
571
572     OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
573     LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
574     if (immediately)
575         m_document->databaseThread()->scheduleImmediateTask(task.release());
576     else
577         m_document->databaseThread()->scheduleTask(task.release());
578 }
579
580 void Database::scheduleTransactionCallback(SQLTransaction* transaction)
581 {
582     transaction->ref();
583     callOnMainThread(deliverPendingCallback, transaction);
584 }
585
586 Vector<String> Database::performGetTableNames()
587 {
588     disableAuthorizer();
589
590     SQLiteStatement statement(m_sqliteDatabase, "SELECT name FROM sqlite_master WHERE type='table';");
591     if (statement.prepare() != SQLResultOk) {
592         LOG_ERROR("Unable to retrieve list of tables for database %s", databaseDebugName().ascii().data());
593         enableAuthorizer();
594         return Vector<String>();
595     }
596
597     Vector<String> tableNames;
598     int result;
599     while ((result = statement.step()) == SQLResultRow) {
600         String name = statement.getColumnText(0);
601         if (name != databaseInfoTableName())
602             tableNames.append(name);
603     }
604
605     enableAuthorizer();
606
607     if (result != SQLResultDone) {
608         LOG_ERROR("Error getting tables for database %s", databaseDebugName().ascii().data());
609         return Vector<String>();
610     }
611
612     return tableNames;
613 }
614
615 SQLTransactionClient* Database::transactionClient() const
616 {
617     return m_document->databaseThread()->transactionClient();
618 }
619
620 SQLTransactionCoordinator* Database::transactionCoordinator() const
621 {
622     return m_document->databaseThread()->transactionCoordinator();
623 }
624
625 String Database::version() const
626 {
627     if (m_deleted)
628         return String();
629     MutexLocker locker(guidMutex());
630     return guidToVersionMap().get(m_guid).threadsafeCopy();
631 }
632
633 void Database::deliverPendingCallback(void* context)
634 {
635     SQLTransaction* transaction = static_cast<SQLTransaction*>(context);
636     transaction->performPendingCallback();
637     transaction->deref(); // Was ref'd in scheduleTransactionCallback().
638 }
639
640 Vector<String> Database::tableNames()
641 {
642     // FIXME: Not using threadsafeCopy on these strings looks ok since threads take strict turns
643     // in dealing with them. However, if the code changes, this may not be true anymore.
644     Vector<String> result;
645     if (!m_document->databaseThread())
646         return result;
647
648     DatabaseTaskSynchronizer synchronizer;
649     OwnPtr<DatabaseTableNamesTask> task = DatabaseTableNamesTask::create(this, &synchronizer, result);
650
651     m_document->databaseThread()->scheduleImmediateTask(task.release());
652     synchronizer.waitForTaskCompletion();
653
654     return result;
655 }
656
657 void Database::setExpectedVersion(const String& version)
658 {
659     m_expectedVersion = version.threadsafeCopy();
660     // Update the in memory database version map.
661     MutexLocker locker(guidMutex());
662     updateGuidVersionMap(m_guid, version);
663 }
664
665 SecurityOrigin* Database::securityOrigin() const
666 {
667     if (isMainThread())
668         return m_mainThreadSecurityOrigin.get();
669     if (currentThread() == document()->databaseThread()->getThreadID())
670         return m_databaseThreadSecurityOrigin.get();
671     return 0;
672 }
673
674 String Database::stringIdentifier() const
675 {
676     // Return a deep copy for ref counting thread safety
677     return m_name.threadsafeCopy();
678 }
679
680 String Database::displayName() const
681 {
682     // Return a deep copy for ref counting thread safety
683     return m_displayName.threadsafeCopy();
684 }
685
686 unsigned long Database::estimatedSize() const
687 {
688     return m_estimatedSize;
689 }
690
691 String Database::fileName() const
692 {
693     // Return a deep copy for ref counting thread safety
694     return m_filename.threadsafeCopy();
695 }
696
697 #endif
698
699 }