dbbc125260a3c27d9bb545b271129303ea1b27e9
[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 "IDBConnectionToClient.h"
32 #include "IDBConnectionToServer.h"
33 #include "IDBCursorInfo.h"
34 #include "IDBKeyRangeData.h"
35 #include "IDBOpenDBRequestImpl.h"
36 #include "IDBRequestData.h"
37 #include "IDBResultData.h"
38 #include "Logging.h"
39 #include <wtf/RunLoop.h>
40
41 namespace WebCore {
42
43 Ref<InProcessIDBServer> InProcessIDBServer::create()
44 {
45     Ref<InProcessIDBServer> server = adoptRef(*new InProcessIDBServer);
46     server->m_server->registerConnection(server->connectionToClient());
47     return WTF::move(server);
48 }
49
50 InProcessIDBServer::InProcessIDBServer()
51     : m_server(IDBServer::IDBServer::create())
52 {
53     relaxAdoptionRequirement();
54     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);
55     m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
56 }
57
58 uint64_t InProcessIDBServer::identifier() const
59 {
60     // An instance of InProcessIDBServer always has a 1:1 relationship with its instance of IDBServer.
61     // Therefore the connection identifier between the two can always be "1".
62     return 1;
63 }
64
65 IDBClient::IDBConnectionToServer& InProcessIDBServer::connectionToServer() const
66 {
67     return *m_connectionToServer;
68 }
69
70 IDBServer::IDBConnectionToClient& InProcessIDBServer::connectionToClient() const
71 {
72     return *m_connectionToClient;
73 }
74
75 void InProcessIDBServer::deleteDatabase(IDBRequestData& requestData)
76 {
77     RefPtr<InProcessIDBServer> self(this);
78     RunLoop::current().dispatch([this, self, requestData] {
79         m_server->deleteDatabase(requestData);
80     });
81 }
82
83 void InProcessIDBServer::didDeleteDatabase(const IDBResultData& resultData)
84 {
85     RefPtr<InProcessIDBServer> self(this);
86     RunLoop::current().dispatch([this, self, resultData] {
87         m_connectionToServer->didDeleteDatabase(resultData);
88     });
89 }
90
91 void InProcessIDBServer::openDatabase(IDBRequestData& requestData)
92 {
93     RefPtr<InProcessIDBServer> self(this);
94     RunLoop::current().dispatch([this, self, requestData] {
95         m_server->openDatabase(requestData);
96     });
97 }
98
99 void InProcessIDBServer::didOpenDatabase(const IDBResultData& resultData)
100 {
101     RefPtr<InProcessIDBServer> self(this);
102     RunLoop::current().dispatch([this, self, resultData] {
103         m_connectionToServer->didOpenDatabase(resultData);
104     });
105 }
106
107 void InProcessIDBServer::didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
108 {
109     RefPtr<InProcessIDBServer> self(this);
110     RunLoop::current().dispatch([this, self, transactionIdentifier, error] {
111         m_connectionToServer->didAbortTransaction(transactionIdentifier, error);
112     });
113 }
114
115 void InProcessIDBServer::didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
116 {
117     RefPtr<InProcessIDBServer> self(this);
118     RunLoop::current().dispatch([this, self, transactionIdentifier, error] {
119         m_connectionToServer->didCommitTransaction(transactionIdentifier, error);
120     });
121 }
122
123 void InProcessIDBServer::didCreateObjectStore(const IDBResultData& resultData)
124 {
125     RefPtr<InProcessIDBServer> self(this);
126     RunLoop::current().dispatch([this, self, resultData] {
127         m_connectionToServer->didCreateObjectStore(resultData);
128     });
129 }
130
131 void InProcessIDBServer::didDeleteObjectStore(const IDBResultData& resultData)
132 {
133     RefPtr<InProcessIDBServer> self(this);
134     RunLoop::current().dispatch([this, self, resultData] {
135         m_connectionToServer->didDeleteObjectStore(resultData);
136     });
137 }
138
139 void InProcessIDBServer::didClearObjectStore(const IDBResultData& resultData)
140 {
141     RefPtr<InProcessIDBServer> self(this);
142     RunLoop::current().dispatch([this, self, resultData] {
143         m_connectionToServer->didClearObjectStore(resultData);
144     });
145 }
146
147 void InProcessIDBServer::didCreateIndex(const IDBResultData& resultData)
148 {
149     RefPtr<InProcessIDBServer> self(this);
150     RunLoop::current().dispatch([this, self, resultData] {
151         m_connectionToServer->didCreateIndex(resultData);
152     });
153 }
154
155 void InProcessIDBServer::didPutOrAdd(const IDBResultData& resultData)
156 {
157     RefPtr<InProcessIDBServer> self(this);
158     RunLoop::current().dispatch([this, self, resultData] {
159         m_connectionToServer->didPutOrAdd(resultData);
160     });
161 }
162
163 void InProcessIDBServer::didGetRecord(const IDBResultData& resultData)
164 {
165     RefPtr<InProcessIDBServer> self(this);
166     RunLoop::current().dispatch([this, self, resultData] {
167         m_connectionToServer->didGetRecord(resultData);
168     });
169 }
170
171 void InProcessIDBServer::didGetCount(const IDBResultData& resultData)
172 {
173     RefPtr<InProcessIDBServer> self(this);
174     RunLoop::current().dispatch([this, self, resultData] {
175         m_connectionToServer->didGetCount(resultData);
176     });
177 }
178
179 void InProcessIDBServer::didDeleteRecord(const IDBResultData& resultData)
180 {
181     RefPtr<InProcessIDBServer> self(this);
182     RunLoop::current().dispatch([this, self, resultData] {
183         m_connectionToServer->didDeleteRecord(resultData);
184     });
185 }
186
187 void InProcessIDBServer::didOpenCursor(const IDBResultData& resultData)
188 {
189     RefPtr<InProcessIDBServer> self(this);
190     RunLoop::current().dispatch([this, self, resultData] {
191         m_connectionToServer->didOpenCursor(resultData);
192     });
193 }
194
195 void InProcessIDBServer::didIterateCursor(const IDBResultData& resultData)
196 {
197     RefPtr<InProcessIDBServer> self(this);
198     RunLoop::current().dispatch([this, self, resultData] {
199         m_connectionToServer->didIterateCursor(resultData);
200     });
201 }
202
203 void InProcessIDBServer::abortTransaction(IDBResourceIdentifier& resourceIdentifier)
204 {
205     RefPtr<InProcessIDBServer> self(this);
206     RunLoop::current().dispatch([this, self, resourceIdentifier] {
207         m_server->abortTransaction(resourceIdentifier);
208     });
209 }
210
211 void InProcessIDBServer::commitTransaction(IDBResourceIdentifier& resourceIdentifier)
212 {
213     RefPtr<InProcessIDBServer> self(this);
214     RunLoop::current().dispatch([this, self, resourceIdentifier] {
215         m_server->commitTransaction(resourceIdentifier);
216     });
217 }
218
219 void InProcessIDBServer::createObjectStore(const IDBRequestData& resultData, const IDBObjectStoreInfo& info)
220 {
221     RefPtr<InProcessIDBServer> self(this);
222     RunLoop::current().dispatch([this, self, resultData, info] {
223         m_server->createObjectStore(resultData, info);
224     });
225 }
226
227 void InProcessIDBServer::deleteObjectStore(const IDBRequestData& requestData, const String& objectStoreName)
228 {
229     RefPtr<InProcessIDBServer> self(this);
230     RunLoop::current().dispatch([this, self, requestData, objectStoreName] {
231         m_server->deleteObjectStore(requestData, objectStoreName);
232     });
233 }
234
235 void InProcessIDBServer::clearObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier)
236 {
237     RefPtr<InProcessIDBServer> self(this);
238     RunLoop::current().dispatch([this, self, requestData, objectStoreIdentifier] {
239         m_server->clearObjectStore(requestData, objectStoreIdentifier);
240     });
241 }
242
243 void InProcessIDBServer::createIndex(const IDBRequestData& resultData, const IDBIndexInfo& info)
244 {
245     RefPtr<InProcessIDBServer> self(this);
246     RunLoop::current().dispatch([this, self, resultData, info] {
247         m_server->createIndex(resultData, info);
248     });
249 }
250
251 void InProcessIDBServer::putOrAdd(const IDBRequestData& requestData, IDBKey* key, SerializedScriptValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
252 {
253     RefPtr<InProcessIDBServer> self(this);
254     IDBKeyData keyData(key);
255     auto valueData = ThreadSafeDataBuffer::copyVector(value.data());
256
257     RunLoop::current().dispatch([this, self, requestData, keyData, valueData, overwriteMode] {
258         m_server->putOrAdd(requestData, keyData, valueData, overwriteMode);
259     });
260 }
261
262 void InProcessIDBServer::getRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
263 {
264     RefPtr<InProcessIDBServer> self(this);
265
266     RunLoop::current().dispatch([this, self, requestData, keyRangeData] {
267         m_server->getRecord(requestData, keyRangeData);
268     });
269 }
270
271 void InProcessIDBServer::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
272 {
273     RefPtr<InProcessIDBServer> self(this);
274     RunLoop::current().dispatch([this, self, requestData, keyRangeData] {
275         m_server->getCount(requestData, keyRangeData);
276     });
277 }
278
279 void InProcessIDBServer::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
280 {
281     RefPtr<InProcessIDBServer> self(this);
282
283     RunLoop::current().dispatch([this, self, requestData, keyRangeData] {
284         m_server->deleteRecord(requestData, keyRangeData);
285     });
286 }
287
288 void InProcessIDBServer::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info)
289 {
290     RefPtr<InProcessIDBServer> self(this);
291
292     RunLoop::current().dispatch([this, self, requestData, info] {
293         m_server->openCursor(requestData, info);
294     });
295 }
296
297 void InProcessIDBServer::iterateCursor(const IDBRequestData& requestData, const IDBKeyData& key, unsigned long count)
298 {
299     RefPtr<InProcessIDBServer> self(this);
300
301     RunLoop::current().dispatch([this, self, requestData, key, count] {
302         m_server->iterateCursor(requestData, key, count);
303     });
304 }
305
306 void InProcessIDBServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
307 {
308     RefPtr<InProcessIDBServer> self(this);
309
310     RunLoop::current().dispatch([this, self, databaseConnectionIdentifier, info] {
311         m_server->establishTransaction(databaseConnectionIdentifier, info);
312     });
313 }
314
315 void InProcessIDBServer::fireVersionChangeEvent(IDBServer::UniqueIDBDatabaseConnection& connection, uint64_t requestedVersion)
316 {
317     RefPtr<InProcessIDBServer> self(this);
318     uint64_t databaseConnectionIdentifier = connection.identifier();
319     RunLoop::current().dispatch([this, self, databaseConnectionIdentifier, requestedVersion] {
320         m_connectionToServer->fireVersionChangeEvent(databaseConnectionIdentifier, requestedVersion);
321     });
322 }
323
324 void InProcessIDBServer::didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
325 {
326     RefPtr<InProcessIDBServer> self(this);
327     RunLoop::current().dispatch([this, self, transactionIdentifier, error] {
328         m_connectionToServer->didStartTransaction(transactionIdentifier, error);
329     });
330 }
331
332 void InProcessIDBServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
333 {
334     RefPtr<InProcessIDBServer> self(this);
335     RunLoop::current().dispatch([this, self, databaseConnectionIdentifier] {
336         m_server->databaseConnectionClosed(databaseConnectionIdentifier);
337     });
338 }
339
340 } // namespace WebCore
341
342 #endif // ENABLE(INDEXED_DATABASE)