8b744b8c68c3fcb04bd13156abd70b3c61231910
[WebKit-https.git] / Source / WebCore / Modules / webdatabase / DatabaseSync.cpp
1 /*
2  * Copyright (C) 2010 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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "DatabaseSync.h"
33
34 #if ENABLE(SQL_DATABASE)
35
36 #include "DatabaseCallback.h"
37 #include "DatabaseTracker.h"
38 #include "Logging.h"
39 #include "SQLException.h"
40 #include "SQLTransactionSync.h"
41 #include "SQLTransactionSyncCallback.h"
42 #include "ScriptExecutionContext.h"
43 #include "SecurityOrigin.h"
44 #include <wtf/PassRefPtr.h>
45 #include <wtf/RefPtr.h>
46 #include <wtf/text/CString.h>
47
48 namespace WebCore {
49
50 PassRefPtr<DatabaseSync> DatabaseSync::openDatabaseSync(ScriptExecutionContext* context, const String& name, const String& expectedVersion, const String& displayName,
51                                                         unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback, ExceptionCode& ec)
52 {
53     ASSERT(context->isContextThread());
54
55     if (!DatabaseTracker::tracker().canEstablishDatabase(context, name, displayName, estimatedSize)) {
56         LOG(StorageAPI, "Database %s for origin %s not allowed to be established", name.ascii().data(), context->securityOrigin()->toString().ascii().data());
57         return 0;
58     }
59
60     RefPtr<DatabaseSync> database = adoptRef(new DatabaseSync(context, name, expectedVersion, displayName, estimatedSize));
61
62     String errorMessage;
63     if (!database->performOpenAndVerify(!creationCallback, ec, errorMessage)) {
64         database->logErrorMessage(errorMessage);
65         DatabaseTracker::tracker().removeOpenDatabase(database.get());
66         return 0;
67     }
68
69     DatabaseTracker::tracker().setDatabaseDetails(context->securityOrigin(), name, displayName, estimatedSize);
70
71     if (database->isNew() && creationCallback.get()) {
72         LOG(StorageAPI, "Invoking the creation callback for database %p\n", database.get());
73         creationCallback->handleEvent(database.get());
74     }
75
76     return database;
77 }
78
79 DatabaseSync::DatabaseSync(ScriptExecutionContext* context, const String& name, const String& expectedVersion,
80                            const String& displayName, unsigned long estimatedSize)
81     : AbstractDatabase(context, name, expectedVersion, displayName, estimatedSize, SyncDatabase)
82 {
83 }
84
85 DatabaseSync::~DatabaseSync()
86 {
87     ASSERT(m_scriptExecutionContext->isContextThread());
88
89     if (opened()) {
90         DatabaseTracker::tracker().removeOpenDatabase(this);
91         closeDatabase();
92     }
93 }
94
95 void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionCode& ec)
96 {
97     ASSERT(m_scriptExecutionContext->isContextThread());
98
99     if (sqliteDatabase().transactionInProgress()) {
100         reportChangeVersionResult(1, SQLException::DATABASE_ERR, 0);
101         setLastErrorMessage("unable to changeVersion from within a transaction");
102         ec = SQLException::DATABASE_ERR;
103         return;
104     }
105
106     RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
107     if ((ec = transaction->begin())) {
108         ASSERT(!lastErrorMessage().isEmpty());
109         return;
110     }
111
112     String actualVersion;
113     if (!getVersionFromDatabase(actualVersion)) {
114         reportChangeVersionResult(2, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
115         setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
116         ec = SQLException::UNKNOWN_ERR;
117         return;
118     }
119
120     if (actualVersion != oldVersion) {
121         reportChangeVersionResult(3, SQLException::VERSION_ERR, 0);
122         setLastErrorMessage("current version of the database and `oldVersion` argument do not match");
123         ec = SQLException::VERSION_ERR;
124         return;
125     }
126
127     if ((ec = transaction->execute())) {
128         ASSERT(!lastErrorMessage().isEmpty());
129         return;
130     }
131
132     if (!setVersionInDatabase(newVersion)) {
133         reportChangeVersionResult(4, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
134         setLastErrorMessage("unable to set the new version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
135         ec = SQLException::UNKNOWN_ERR;
136         return;
137     }
138
139     if ((ec = transaction->commit())) {
140         ASSERT(!lastErrorMessage().isEmpty());
141         setCachedVersion(oldVersion);
142         return;
143     }
144
145     reportChangeVersionResult(0, -1, 0); // OK
146
147     setExpectedVersion(newVersion);
148     setLastErrorMessage("");
149 }
150
151 void DatabaseSync::transaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionCode& ec)
152 {
153     runTransaction(callback, false, ec);
154 }
155
156 void DatabaseSync::readTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionCode& ec)
157 {
158     runTransaction(callback, true, ec);
159 }
160
161 void DatabaseSync::runTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionCode& ec)
162 {
163     ASSERT(m_scriptExecutionContext->isContextThread());
164
165     if (sqliteDatabase().transactionInProgress()) {
166         setLastErrorMessage("unable to start a transaction from within a transaction");
167         ec = SQLException::DATABASE_ERR;
168         return;
169     }
170
171     RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
172     if ((ec = transaction->begin()) || (ec = transaction->execute()) || (ec = transaction->commit())) {
173         ASSERT(!lastErrorMessage().isEmpty());
174         transaction->rollback();
175     }
176
177     setLastErrorMessage("");
178 }
179
180 void DatabaseSync::markAsDeletedAndClose()
181 {
182     // FIXME: need to do something similar to closeImmediately(), but in a sync way
183 }
184
185 class CloseSyncDatabaseOnContextThreadTask : public ScriptExecutionContext::Task {
186 public:
187     static PassOwnPtr<CloseSyncDatabaseOnContextThreadTask> create(PassRefPtr<DatabaseSync> database)
188     {
189         return adoptPtr(new CloseSyncDatabaseOnContextThreadTask(database));
190     }
191
192     virtual void performTask(ScriptExecutionContext*)
193     {
194         m_database->closeImmediately();
195     }
196
197 private:
198     CloseSyncDatabaseOnContextThreadTask(PassRefPtr<DatabaseSync> database)
199         : m_database(database)
200     {
201     }
202
203     RefPtr<DatabaseSync> m_database;
204 };
205
206 void DatabaseSync::closeImmediately()
207 {
208     ASSERT(m_scriptExecutionContext->isContextThread());
209
210     if (!opened())
211         return;
212
213     logErrorMessage("forcibly closing database");
214     DatabaseTracker::tracker().removeOpenDatabase(this);
215     closeDatabase();
216 }
217
218 } // namespace WebCore
219
220 #endif // ENABLE(SQL_DATABASE)