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