IndexedDB 2.0: Support IDBIndex name assignment.
[WebKit-https.git] / Source / WebCore / Modules / indexeddb / shared / InProcessIDBServer.cpp
1 /*
2  * Copyright (C) 2015 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "InProcessIDBServer.h"
28
29 #if ENABLE(INDEXED_DATABASE)
30
31 #include "FileSystem.h"
32 #include "IDBConnectionToClient.h"
33 #include "IDBConnectionToServer.h"
34 #include "IDBCursorInfo.h"
35 #include "IDBGetRecordData.h"
36 #include "IDBKeyRangeData.h"
37 #include "IDBOpenDBRequest.h"
38 #include "IDBRequestData.h"
39 #include "IDBResultData.h"
40 #include "IDBValue.h"
41 #include "Logging.h"
42 #include <wtf/RunLoop.h>
43
44 namespace WebCore {
45
46 Ref<InProcessIDBServer> InProcessIDBServer::create()
47 {
48     Ref<InProcessIDBServer> server = adoptRef(*new InProcessIDBServer);
49     server->m_server->registerConnection(server->connectionToClient());
50     return server;
51 }
52
53 Ref<InProcessIDBServer> InProcessIDBServer::create(const String& databaseDirectoryPath)
54 {
55     Ref<InProcessIDBServer> server = adoptRef(*new InProcessIDBServer(databaseDirectoryPath));
56     server->m_server->registerConnection(server->connectionToClient());
57     return server;
58 }
59
60 InProcessIDBServer::InProcessIDBServer()
61     : m_server(IDBServer::IDBServer::create(*this))
62 {
63     relaxAdoptionRequirement();
64     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);
65     m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
66 }
67
68 InProcessIDBServer::InProcessIDBServer(const String& databaseDirectoryPath)
69     : m_server(IDBServer::IDBServer::create(databaseDirectoryPath, *this))
70 {
71     relaxAdoptionRequirement();
72     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);
73     m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
74 }
75
76 uint64_t InProcessIDBServer::identifier() const
77 {
78     // An instance of InProcessIDBServer always has a 1:1 relationship with its instance of IDBServer.
79     // Therefore the connection identifier between the two can always be "1".
80     return 1;
81 }
82
83 IDBClient::IDBConnectionToServer& InProcessIDBServer::connectionToServer() const
84 {
85     return *m_connectionToServer;
86 }
87
88 IDBServer::IDBConnectionToClient& InProcessIDBServer::connectionToClient() const
89 {
90     return *m_connectionToClient;
91 }
92
93 void InProcessIDBServer::deleteDatabase(const IDBRequestData& requestData)
94 {
95     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData] {
96         m_server->deleteDatabase(requestData);
97     });
98 }
99
100 void InProcessIDBServer::didDeleteDatabase(const IDBResultData& resultData)
101 {
102     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
103         m_connectionToServer->didDeleteDatabase(resultData);
104     });
105 }
106
107 void InProcessIDBServer::openDatabase(const IDBRequestData& requestData)
108 {
109     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData] {
110         m_server->openDatabase(requestData);
111     });
112 }
113
114 void InProcessIDBServer::didOpenDatabase(const IDBResultData& resultData)
115 {
116     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
117         m_connectionToServer->didOpenDatabase(resultData);
118     });
119 }
120
121 void InProcessIDBServer::didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
122 {
123     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), transactionIdentifier, error] {
124         m_connectionToServer->didAbortTransaction(transactionIdentifier, error);
125     });
126 }
127
128 void InProcessIDBServer::didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
129 {
130     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), transactionIdentifier, error] {
131         m_connectionToServer->didCommitTransaction(transactionIdentifier, error);
132     });
133 }
134
135 void InProcessIDBServer::didCreateObjectStore(const IDBResultData& resultData)
136 {
137     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
138         m_connectionToServer->didCreateObjectStore(resultData);
139     });
140 }
141
142 void InProcessIDBServer::didDeleteObjectStore(const IDBResultData& resultData)
143 {
144     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
145         m_connectionToServer->didDeleteObjectStore(resultData);
146     });
147 }
148
149 void InProcessIDBServer::didRenameObjectStore(const IDBResultData& resultData)
150 {
151     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
152         m_connectionToServer->didRenameObjectStore(resultData);
153     });
154 }
155
156 void InProcessIDBServer::didClearObjectStore(const IDBResultData& resultData)
157 {
158     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
159         m_connectionToServer->didClearObjectStore(resultData);
160     });
161 }
162
163 void InProcessIDBServer::didCreateIndex(const IDBResultData& resultData)
164 {
165     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
166         m_connectionToServer->didCreateIndex(resultData);
167     });
168 }
169
170 void InProcessIDBServer::didDeleteIndex(const IDBResultData& resultData)
171 {
172     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
173         m_connectionToServer->didDeleteIndex(resultData);
174     });
175 }
176
177 void InProcessIDBServer::didRenameIndex(const IDBResultData& resultData)
178 {
179     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
180         m_connectionToServer->didRenameIndex(resultData);
181     });
182 }
183
184 void InProcessIDBServer::didPutOrAdd(const IDBResultData& resultData)
185 {
186     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
187         m_connectionToServer->didPutOrAdd(resultData);
188     });
189 }
190
191 void InProcessIDBServer::didGetRecord(const IDBResultData& resultData)
192 {
193     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
194         m_connectionToServer->didGetRecord(resultData);
195     });
196 }
197
198 void InProcessIDBServer::didGetCount(const IDBResultData& resultData)
199 {
200     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
201         m_connectionToServer->didGetCount(resultData);
202     });
203 }
204
205 void InProcessIDBServer::didDeleteRecord(const IDBResultData& resultData)
206 {
207     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
208         m_connectionToServer->didDeleteRecord(resultData);
209     });
210 }
211
212 void InProcessIDBServer::didOpenCursor(const IDBResultData& resultData)
213 {
214     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
215         m_connectionToServer->didOpenCursor(resultData);
216     });
217 }
218
219 void InProcessIDBServer::didIterateCursor(const IDBResultData& resultData)
220 {
221     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
222         m_connectionToServer->didIterateCursor(resultData);
223     });
224 }
225
226 void InProcessIDBServer::abortTransaction(const IDBResourceIdentifier& resourceIdentifier)
227 {
228     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resourceIdentifier] {
229         m_server->abortTransaction(resourceIdentifier);
230     });
231 }
232
233 void InProcessIDBServer::commitTransaction(const IDBResourceIdentifier& resourceIdentifier)
234 {
235     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resourceIdentifier] {
236         m_server->commitTransaction(resourceIdentifier);
237     });
238 }
239
240 void InProcessIDBServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
241 {
242     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, transactionIdentifier] {
243         m_server->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
244     });
245 }
246
247 void InProcessIDBServer::createObjectStore(const IDBRequestData& resultData, const IDBObjectStoreInfo& info)
248 {
249     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData, info] {
250         m_server->createObjectStore(resultData, info);
251     });
252 }
253
254 void InProcessIDBServer::deleteObjectStore(const IDBRequestData& requestData, const String& objectStoreName)
255 {
256     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreName] {
257         m_server->deleteObjectStore(requestData, objectStoreName);
258     });
259 }
260
261 void InProcessIDBServer::renameObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& newName)
262 {
263     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier, newName] {
264         m_server->renameObjectStore(requestData, objectStoreIdentifier, newName);
265     });
266 }
267
268 void InProcessIDBServer::clearObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier)
269 {
270     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier] {
271         m_server->clearObjectStore(requestData, objectStoreIdentifier);
272     });
273 }
274
275 void InProcessIDBServer::createIndex(const IDBRequestData& requestData, const IDBIndexInfo& info)
276 {
277     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, info] {
278         m_server->createIndex(requestData, info);
279     });
280 }
281
282 void InProcessIDBServer::deleteIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
283 {
284     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier, indexName] {
285         m_server->deleteIndex(requestData, objectStoreIdentifier, indexName);
286     });
287 }
288
289 void InProcessIDBServer::renameIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
290 {
291     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier, indexIdentifier, newName] {
292         m_server->renameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName);
293     });
294 }
295
296 void InProcessIDBServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
297 {
298     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, keyData, value, overwriteMode] {
299         m_server->putOrAdd(requestData, keyData, value, overwriteMode);
300     });
301 }
302
303 void InProcessIDBServer::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData)
304 {
305     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, getRecordData] {
306         m_server->getRecord(requestData, getRecordData);
307     });
308 }
309
310 void InProcessIDBServer::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
311 {
312     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, keyRangeData] {
313         m_server->getCount(requestData, keyRangeData);
314     });
315 }
316
317 void InProcessIDBServer::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
318 {
319     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, keyRangeData] {
320         m_server->deleteRecord(requestData, keyRangeData);
321     });
322 }
323
324 void InProcessIDBServer::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info)
325 {
326     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, info] {
327         m_server->openCursor(requestData, info);
328     });
329 }
330
331 void InProcessIDBServer::iterateCursor(const IDBRequestData& requestData, const IDBKeyData& key, unsigned long count)
332 {
333     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, key, count] {
334         m_server->iterateCursor(requestData, key, count);
335     });
336 }
337
338 void InProcessIDBServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
339 {
340     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, info] {
341         m_server->establishTransaction(databaseConnectionIdentifier, info);
342     });
343 }
344
345 void InProcessIDBServer::fireVersionChangeEvent(IDBServer::UniqueIDBDatabaseConnection& connection, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
346 {
347     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier = connection.identifier(), requestIdentifier, requestedVersion] {
348         m_connectionToServer->fireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, requestedVersion);
349     });
350 }
351
352 void InProcessIDBServer::didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
353 {
354     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), transactionIdentifier, error] {
355         m_connectionToServer->didStartTransaction(transactionIdentifier, error);
356     });
357 }
358
359 void InProcessIDBServer::didCloseFromServer(IDBServer::UniqueIDBDatabaseConnection& connection, const IDBError& error)
360 {
361     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier = connection.identifier(), error] {
362         m_connectionToServer->didCloseFromServer(databaseConnectionIdentifier, error);
363     });
364 }
365
366 void InProcessIDBServer::notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
367 {
368     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestIdentifier, oldVersion, newVersion] {
369         m_connectionToServer->notifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion);
370     });
371 }
372
373 void InProcessIDBServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
374 {
375     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier] {
376         m_server->databaseConnectionClosed(databaseConnectionIdentifier);
377     });
378 }
379
380 void InProcessIDBServer::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
381 {
382     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, transactionIdentifier] {
383         m_server->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
384     });
385 }
386
387 void InProcessIDBServer::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier)
388 {
389     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, requestIdentifier] {
390         m_server->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
391     });
392 }
393
394 void InProcessIDBServer::openDBRequestCancelled(const IDBRequestData& requestData)
395 {
396     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData] {
397         m_server->openDBRequestCancelled(requestData);
398     });
399 }
400
401 void InProcessIDBServer::confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier)
402 {
403     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier] {
404         m_server->confirmDidCloseFromServer(databaseConnectionIdentifier);
405     });
406 }
407
408 void InProcessIDBServer::getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID)
409 {
410     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), mainFrameOrigin, openingOrigin, callbackID] {
411         m_server->getAllDatabaseNames(m_connectionToServer->identifier(), mainFrameOrigin, openingOrigin, callbackID);
412     });
413 }
414
415 void InProcessIDBServer::didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames)
416 {
417     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), callbackID, databaseNames] {
418         m_connectionToServer->didGetAllDatabaseNames(callbackID, databaseNames);
419     });
420 }
421
422 void InProcessIDBServer::accessToTemporaryFileComplete(const String& path)
423 {
424     deleteFile(path);
425 }
426
427 } // namespace WebCore
428
429 #endif // ENABLE(INDEXED_DATABASE)