IndexedDB 2.0: Encapsulate cursor iteration parameters for easy future expansion.
[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 "IDBIterateCursorData.h"
37 #include "IDBKeyRangeData.h"
38 #include "IDBOpenDBRequest.h"
39 #include "IDBRequestData.h"
40 #include "IDBResultData.h"
41 #include "IDBValue.h"
42 #include "Logging.h"
43 #include <wtf/RunLoop.h>
44
45 namespace WebCore {
46
47 Ref<InProcessIDBServer> InProcessIDBServer::create()
48 {
49     Ref<InProcessIDBServer> server = adoptRef(*new InProcessIDBServer);
50     server->m_server->registerConnection(server->connectionToClient());
51     return server;
52 }
53
54 Ref<InProcessIDBServer> InProcessIDBServer::create(const String& databaseDirectoryPath)
55 {
56     Ref<InProcessIDBServer> server = adoptRef(*new InProcessIDBServer(databaseDirectoryPath));
57     server->m_server->registerConnection(server->connectionToClient());
58     return server;
59 }
60
61 InProcessIDBServer::InProcessIDBServer()
62     : m_server(IDBServer::IDBServer::create(*this))
63 {
64     relaxAdoptionRequirement();
65     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);
66     m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
67 }
68
69 InProcessIDBServer::InProcessIDBServer(const String& databaseDirectoryPath)
70     : m_server(IDBServer::IDBServer::create(databaseDirectoryPath, *this))
71 {
72     relaxAdoptionRequirement();
73     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);
74     m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
75 }
76
77 uint64_t InProcessIDBServer::identifier() const
78 {
79     // An instance of InProcessIDBServer always has a 1:1 relationship with its instance of IDBServer.
80     // Therefore the connection identifier between the two can always be "1".
81     return 1;
82 }
83
84 IDBClient::IDBConnectionToServer& InProcessIDBServer::connectionToServer() const
85 {
86     return *m_connectionToServer;
87 }
88
89 IDBServer::IDBConnectionToClient& InProcessIDBServer::connectionToClient() const
90 {
91     return *m_connectionToClient;
92 }
93
94 void InProcessIDBServer::deleteDatabase(const IDBRequestData& requestData)
95 {
96     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData] {
97         m_server->deleteDatabase(requestData);
98     });
99 }
100
101 void InProcessIDBServer::didDeleteDatabase(const IDBResultData& resultData)
102 {
103     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
104         m_connectionToServer->didDeleteDatabase(resultData);
105     });
106 }
107
108 void InProcessIDBServer::openDatabase(const IDBRequestData& requestData)
109 {
110     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData] {
111         m_server->openDatabase(requestData);
112     });
113 }
114
115 void InProcessIDBServer::didOpenDatabase(const IDBResultData& resultData)
116 {
117     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
118         m_connectionToServer->didOpenDatabase(resultData);
119     });
120 }
121
122 void InProcessIDBServer::didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
123 {
124     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), transactionIdentifier, error] {
125         m_connectionToServer->didAbortTransaction(transactionIdentifier, error);
126     });
127 }
128
129 void InProcessIDBServer::didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
130 {
131     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), transactionIdentifier, error] {
132         m_connectionToServer->didCommitTransaction(transactionIdentifier, error);
133     });
134 }
135
136 void InProcessIDBServer::didCreateObjectStore(const IDBResultData& resultData)
137 {
138     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
139         m_connectionToServer->didCreateObjectStore(resultData);
140     });
141 }
142
143 void InProcessIDBServer::didDeleteObjectStore(const IDBResultData& resultData)
144 {
145     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
146         m_connectionToServer->didDeleteObjectStore(resultData);
147     });
148 }
149
150 void InProcessIDBServer::didRenameObjectStore(const IDBResultData& resultData)
151 {
152     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
153         m_connectionToServer->didRenameObjectStore(resultData);
154     });
155 }
156
157 void InProcessIDBServer::didClearObjectStore(const IDBResultData& resultData)
158 {
159     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
160         m_connectionToServer->didClearObjectStore(resultData);
161     });
162 }
163
164 void InProcessIDBServer::didCreateIndex(const IDBResultData& resultData)
165 {
166     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
167         m_connectionToServer->didCreateIndex(resultData);
168     });
169 }
170
171 void InProcessIDBServer::didDeleteIndex(const IDBResultData& resultData)
172 {
173     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
174         m_connectionToServer->didDeleteIndex(resultData);
175     });
176 }
177
178 void InProcessIDBServer::didRenameIndex(const IDBResultData& resultData)
179 {
180     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
181         m_connectionToServer->didRenameIndex(resultData);
182     });
183 }
184
185 void InProcessIDBServer::didPutOrAdd(const IDBResultData& resultData)
186 {
187     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
188         m_connectionToServer->didPutOrAdd(resultData);
189     });
190 }
191
192 void InProcessIDBServer::didGetRecord(const IDBResultData& resultData)
193 {
194     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
195         m_connectionToServer->didGetRecord(resultData);
196     });
197 }
198
199 void InProcessIDBServer::didGetAllRecords(const IDBResultData& resultData)
200 {
201     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
202         m_connectionToServer->didGetAllRecords(resultData);
203     });
204 }
205
206 void InProcessIDBServer::didGetCount(const IDBResultData& resultData)
207 {
208     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
209         m_connectionToServer->didGetCount(resultData);
210     });
211 }
212
213 void InProcessIDBServer::didDeleteRecord(const IDBResultData& resultData)
214 {
215     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
216         m_connectionToServer->didDeleteRecord(resultData);
217     });
218 }
219
220 void InProcessIDBServer::didOpenCursor(const IDBResultData& resultData)
221 {
222     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
223         m_connectionToServer->didOpenCursor(resultData);
224     });
225 }
226
227 void InProcessIDBServer::didIterateCursor(const IDBResultData& resultData)
228 {
229     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData] {
230         m_connectionToServer->didIterateCursor(resultData);
231     });
232 }
233
234 void InProcessIDBServer::abortTransaction(const IDBResourceIdentifier& resourceIdentifier)
235 {
236     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resourceIdentifier] {
237         m_server->abortTransaction(resourceIdentifier);
238     });
239 }
240
241 void InProcessIDBServer::commitTransaction(const IDBResourceIdentifier& resourceIdentifier)
242 {
243     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resourceIdentifier] {
244         m_server->commitTransaction(resourceIdentifier);
245     });
246 }
247
248 void InProcessIDBServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
249 {
250     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, transactionIdentifier] {
251         m_server->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
252     });
253 }
254
255 void InProcessIDBServer::createObjectStore(const IDBRequestData& resultData, const IDBObjectStoreInfo& info)
256 {
257     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), resultData, info] {
258         m_server->createObjectStore(resultData, info);
259     });
260 }
261
262 void InProcessIDBServer::deleteObjectStore(const IDBRequestData& requestData, const String& objectStoreName)
263 {
264     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreName] {
265         m_server->deleteObjectStore(requestData, objectStoreName);
266     });
267 }
268
269 void InProcessIDBServer::renameObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& newName)
270 {
271     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier, newName] {
272         m_server->renameObjectStore(requestData, objectStoreIdentifier, newName);
273     });
274 }
275
276 void InProcessIDBServer::clearObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier)
277 {
278     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier] {
279         m_server->clearObjectStore(requestData, objectStoreIdentifier);
280     });
281 }
282
283 void InProcessIDBServer::createIndex(const IDBRequestData& requestData, const IDBIndexInfo& info)
284 {
285     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, info] {
286         m_server->createIndex(requestData, info);
287     });
288 }
289
290 void InProcessIDBServer::deleteIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
291 {
292     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier, indexName] {
293         m_server->deleteIndex(requestData, objectStoreIdentifier, indexName);
294     });
295 }
296
297 void InProcessIDBServer::renameIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
298 {
299     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, objectStoreIdentifier, indexIdentifier, newName] {
300         m_server->renameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName);
301     });
302 }
303
304 void InProcessIDBServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
305 {
306     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, keyData, value, overwriteMode] {
307         m_server->putOrAdd(requestData, keyData, value, overwriteMode);
308     });
309 }
310
311 void InProcessIDBServer::getRecord(const IDBRequestData& requestData, const IDBGetRecordData& getRecordData)
312 {
313     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, getRecordData] {
314         m_server->getRecord(requestData, getRecordData);
315     });
316 }
317
318 void InProcessIDBServer::getAllRecords(const IDBRequestData& requestData, const IDBGetAllRecordsData& getAllRecordsData)
319 {
320     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, getAllRecordsData] {
321         m_server->getAllRecords(requestData, getAllRecordsData);
322     });
323 }
324
325 void InProcessIDBServer::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
326 {
327     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, keyRangeData] {
328         m_server->getCount(requestData, keyRangeData);
329     });
330 }
331
332 void InProcessIDBServer::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
333 {
334     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, keyRangeData] {
335         m_server->deleteRecord(requestData, keyRangeData);
336     });
337 }
338
339 void InProcessIDBServer::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info)
340 {
341     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, info] {
342         m_server->openCursor(requestData, info);
343     });
344 }
345
346 void InProcessIDBServer::iterateCursor(const IDBRequestData& requestData, const IDBIterateCursorData& data)
347 {
348     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData, data] {
349         m_server->iterateCursor(requestData, data);
350     });
351 }
352
353 void InProcessIDBServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
354 {
355     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, info] {
356         m_server->establishTransaction(databaseConnectionIdentifier, info);
357     });
358 }
359
360 void InProcessIDBServer::fireVersionChangeEvent(IDBServer::UniqueIDBDatabaseConnection& connection, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
361 {
362     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier = connection.identifier(), requestIdentifier, requestedVersion] {
363         m_connectionToServer->fireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, requestedVersion);
364     });
365 }
366
367 void InProcessIDBServer::didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
368 {
369     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), transactionIdentifier, error] {
370         m_connectionToServer->didStartTransaction(transactionIdentifier, error);
371     });
372 }
373
374 void InProcessIDBServer::didCloseFromServer(IDBServer::UniqueIDBDatabaseConnection& connection, const IDBError& error)
375 {
376     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier = connection.identifier(), error] {
377         m_connectionToServer->didCloseFromServer(databaseConnectionIdentifier, error);
378     });
379 }
380
381 void InProcessIDBServer::notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
382 {
383     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestIdentifier, oldVersion, newVersion] {
384         m_connectionToServer->notifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion);
385     });
386 }
387
388 void InProcessIDBServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
389 {
390     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier] {
391         m_server->databaseConnectionClosed(databaseConnectionIdentifier);
392     });
393 }
394
395 void InProcessIDBServer::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
396 {
397     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, transactionIdentifier] {
398         m_server->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
399     });
400 }
401
402 void InProcessIDBServer::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier)
403 {
404     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier, requestIdentifier] {
405         m_server->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
406     });
407 }
408
409 void InProcessIDBServer::openDBRequestCancelled(const IDBRequestData& requestData)
410 {
411     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), requestData] {
412         m_server->openDBRequestCancelled(requestData);
413     });
414 }
415
416 void InProcessIDBServer::confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier)
417 {
418     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), databaseConnectionIdentifier] {
419         m_server->confirmDidCloseFromServer(databaseConnectionIdentifier);
420     });
421 }
422
423 void InProcessIDBServer::getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID)
424 {
425     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), mainFrameOrigin, openingOrigin, callbackID] {
426         m_server->getAllDatabaseNames(m_connectionToServer->identifier(), mainFrameOrigin, openingOrigin, callbackID);
427     });
428 }
429
430 void InProcessIDBServer::didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames)
431 {
432     RunLoop::current().dispatch([this, protectedThis = makeRef(*this), callbackID, databaseNames] {
433         m_connectionToServer->didGetAllDatabaseNames(callbackID, databaseNames);
434     });
435 }
436
437 void InProcessIDBServer::accessToTemporaryFileComplete(const String& path)
438 {
439     deleteFile(path);
440 }
441
442 } // namespace WebCore
443
444 #endif // ENABLE(INDEXED_DATABASE)