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