← Back to branch summary

~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/WebKit/NetworkProcess/IndexedDB/WebIDBServer.cpp

  • Committer: mmach
  • Date: 2023-06-16 17:21:37 UTC
  • Revision ID: netbit73@gmail.com-20230616172137-2rqx6yr96ga9g3kp
1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebKit/NetworkProcess/IndexedDB/WebIDBServer.cpp
 
1
/*
 
2
 * Copyright (C) 2019 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. ``AS IS'' AND ANY
 
14
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
15
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
16
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 
17
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
18
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
19
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
20
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 
21
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
22
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
23
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
24
 */
 
25
 
 
26
#include "config.h"
 
27
#include "WebIDBServer.h"
 
28
 
 
29
#include "WebIDBConnectionToClient.h"
 
30
#include "WebIDBServerMessages.h"
 
31
#include <WebCore/SQLiteDatabaseTracker.h>
 
32
#include <WebCore/StorageQuotaManager.h>
 
33
#include <wtf/threads/BinarySemaphore.h>
 
34
 
 
35
#if ENABLE(INDEXED_DATABASE)
 
36
 
 
37
namespace WebKit {
 
38
 
 
39
Ref<WebIDBServer> WebIDBServer::create(PAL::SessionID sessionID, const String& directory, WebCore::IDBServer::IDBServer::StorageQuotaManagerSpaceRequester&& spaceRequester)
 
40
{
 
41
    return adoptRef(*new WebIDBServer(sessionID, directory, WTFMove(spaceRequester)));
 
42
}
 
43
 
 
44
WebIDBServer::WebIDBServer(PAL::SessionID sessionID, const String& directory, WebCore::IDBServer::IDBServer::StorageQuotaManagerSpaceRequester&& spaceRequester)
 
45
    : CrossThreadTaskHandler("com.apple.WebKit.IndexedDBServer", WTF::CrossThreadTaskHandler::AutodrainedPoolForRunLoop::Use)
 
46
{
 
47
    ASSERT(RunLoop::isMain());
 
48
 
 
49
    BinarySemaphore semaphore;
 
50
    postTask([this, protectedThis = makeRef(*this), &semaphore, sessionID, directory = directory.isolatedCopy(), spaceRequester = WTFMove(spaceRequester)] () mutable {
 
51
        m_server = makeUnique<WebCore::IDBServer::IDBServer>(sessionID, directory, WTFMove(spaceRequester));
 
52
        semaphore.signal();
 
53
    });
 
54
    semaphore.wait();
 
55
}
 
56
    
 
57
void WebIDBServer::closeAndDeleteDatabasesModifiedSince(WallTime modificationTime, CompletionHandler<void()>&& callback)
 
58
{
 
59
    ASSERT(RunLoop::isMain());
 
60
 
 
61
    postTask([this, protectedThis = makeRef(*this), modificationTime, callback = WTFMove(callback)]() mutable {
 
62
        ASSERT(!RunLoop::isMain());
 
63
 
 
64
        LockHolder locker(m_server->lock());
 
65
        m_server->closeAndDeleteDatabasesModifiedSince(modificationTime);
 
66
        postTaskReply(CrossThreadTask([callback = WTFMove(callback)]() mutable {
 
67
            callback();
 
68
        }));
 
69
    });
 
70
}
 
71
 
 
72
void WebIDBServer::closeAndDeleteDatabasesForOrigins(const Vector<WebCore::SecurityOriginData>& originDatas, CompletionHandler<void()>&& callback)
 
73
{
 
74
    ASSERT(RunLoop::isMain());
 
75
 
 
76
    postTask([this, protectedThis = makeRef(*this), originDatas = originDatas.isolatedCopy(), callback = WTFMove(callback)] () mutable {
 
77
        ASSERT(!RunLoop::isMain());
 
78
 
 
79
        LockHolder locker(m_server->lock());
 
80
        m_server->closeAndDeleteDatabasesForOrigins(originDatas);
 
81
        postTaskReply(CrossThreadTask([callback = WTFMove(callback)]() mutable {
 
82
            callback();
 
83
        }));
 
84
    });
 
85
}
 
86
 
 
87
void WebIDBServer::suspend(ShouldForceStop shouldForceStop)
 
88
{
 
89
    ASSERT(RunLoop::isMain());
 
90
 
 
91
    if (shouldForceStop == ShouldForceStop::No && WebCore::SQLiteDatabaseTracker::hasTransactionInProgress())
 
92
        return;
 
93
 
 
94
    if (m_isSuspended)
 
95
        return;
 
96
 
 
97
    m_isSuspended = true;
 
98
    m_server->lock().lock();
 
99
    m_server->stopDatabaseActivitiesOnMainThread();
 
100
}
 
101
 
 
102
void WebIDBServer::resume()
 
103
{
 
104
    ASSERT(RunLoop::isMain());
 
105
 
 
106
    if (!m_isSuspended)
 
107
        return;
 
108
 
 
109
    m_isSuspended = false;
 
110
    m_server->lock().unlock();
 
111
}
 
112
 
 
113
void WebIDBServer::openDatabase(const WebCore::IDBRequestData& requestData)
 
114
{
 
115
    ASSERT(!RunLoop::isMain());
 
116
 
 
117
    LockHolder locker(m_server->lock());
 
118
    m_server->openDatabase(requestData);
 
119
}
 
120
 
 
121
void WebIDBServer::deleteDatabase(const WebCore::IDBRequestData& requestData)
 
122
{
 
123
    ASSERT(!RunLoop::isMain());
 
124
 
 
125
    LockHolder locker(m_server->lock());
 
126
    m_server->deleteDatabase(requestData);
 
127
}
 
128
 
 
129
void WebIDBServer::abortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier)
 
130
{
 
131
    ASSERT(!RunLoop::isMain());
 
132
 
 
133
    LockHolder locker(m_server->lock());
 
134
    m_server->abortTransaction(transactionIdentifier);
 
135
}
 
136
 
 
137
void WebIDBServer::commitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier)
 
138
{
 
139
    ASSERT(!RunLoop::isMain());
 
140
 
 
141
    LockHolder locker(m_server->lock());
 
142
    m_server->commitTransaction(transactionIdentifier);
 
143
}
 
144
 
 
145
void WebIDBServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier)
 
146
{
 
147
    ASSERT(!RunLoop::isMain());
 
148
 
 
149
    LockHolder locker(m_server->lock());
 
150
    m_server->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
 
151
}
 
152
 
 
153
void WebIDBServer::createObjectStore(const WebCore::IDBRequestData& requestData, const WebCore::IDBObjectStoreInfo& objectStoreInfo)
 
154
{
 
155
    ASSERT(!RunLoop::isMain());
 
156
 
 
157
    LockHolder locker(m_server->lock());
 
158
    m_server->createObjectStore(requestData, objectStoreInfo);
 
159
}
 
160
 
 
161
void WebIDBServer::deleteObjectStore(const WebCore::IDBRequestData& requestData, const String& objectStoreName)
 
162
{
 
163
    ASSERT(!RunLoop::isMain());
 
164
 
 
165
    LockHolder locker(m_server->lock());
 
166
    m_server->deleteObjectStore(requestData, objectStoreName);
 
167
}
 
168
 
 
169
void WebIDBServer::renameObjectStore(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& newName)
 
170
{
 
171
    ASSERT(!RunLoop::isMain());
 
172
 
 
173
    LockHolder locker(m_server->lock());
 
174
    m_server->renameObjectStore(requestData, objectStoreIdentifier, newName);
 
175
}
 
176
 
 
177
void WebIDBServer::clearObjectStore(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier)
 
178
{
 
179
    ASSERT(!RunLoop::isMain());
 
180
 
 
181
    LockHolder locker(m_server->lock());
 
182
    m_server->clearObjectStore(requestData, objectStoreIdentifier);
 
183
}
 
184
 
 
185
void WebIDBServer::createIndex(const WebCore::IDBRequestData& requestData, const WebCore::IDBIndexInfo& indexInfo)
 
186
{
 
187
    ASSERT(!RunLoop::isMain());
 
188
 
 
189
    LockHolder locker(m_server->lock());
 
190
    m_server->createIndex(requestData, indexInfo);
 
191
}
 
192
 
 
193
void WebIDBServer::deleteIndex(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
 
194
{
 
195
    ASSERT(!RunLoop::isMain());
 
196
 
 
197
    LockHolder locker(m_server->lock());
 
198
    m_server->deleteIndex(requestData, objectStoreIdentifier, indexName);
 
199
}
 
200
 
 
201
void WebIDBServer::renameIndex(const WebCore::IDBRequestData& requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
 
202
{
 
203
    ASSERT(!RunLoop::isMain());
 
204
 
 
205
    LockHolder locker(m_server->lock());
 
206
    m_server->renameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName);
 
207
}
 
208
 
 
209
void WebIDBServer::putOrAdd(const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyData& keyData, const WebCore::IDBValue& value, WebCore::IndexedDB::ObjectStoreOverwriteMode overWriteMode)
 
210
{
 
211
    ASSERT(!RunLoop::isMain());
 
212
 
 
213
    LockHolder locker(m_server->lock());
 
214
    m_server->putOrAdd(requestData, keyData, value, overWriteMode);
 
215
}
 
216
 
 
217
void WebIDBServer::getRecord(const WebCore::IDBRequestData& requestData, const WebCore::IDBGetRecordData& getRecordData)
 
218
{
 
219
    ASSERT(!RunLoop::isMain());
 
220
 
 
221
    LockHolder locker(m_server->lock());
 
222
    m_server->getRecord(requestData, getRecordData);
 
223
}
 
224
 
 
225
void WebIDBServer::getAllRecords(const WebCore::IDBRequestData& requestData, const WebCore::IDBGetAllRecordsData& getAllRecordsData)
 
226
{
 
227
    ASSERT(!RunLoop::isMain());
 
228
 
 
229
    LockHolder locker(m_server->lock());
 
230
    m_server->getAllRecords(requestData, getAllRecordsData);
 
231
}
 
232
 
 
233
void WebIDBServer::getCount(const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyRangeData& keyRangeData)
 
234
{
 
235
    ASSERT(!RunLoop::isMain());
 
236
 
 
237
    LockHolder locker(m_server->lock());
 
238
    m_server->getCount(requestData, keyRangeData);
 
239
}
 
240
 
 
241
void WebIDBServer::deleteRecord(const WebCore::IDBRequestData& requestData, const WebCore::IDBKeyRangeData& keyRangeData)
 
242
{
 
243
    ASSERT(!RunLoop::isMain());
 
244
 
 
245
    LockHolder locker(m_server->lock());
 
246
    m_server->deleteRecord(requestData, keyRangeData);
 
247
}
 
248
 
 
249
void WebIDBServer::openCursor(const WebCore::IDBRequestData& requestData, const WebCore::IDBCursorInfo& cursorInfo)
 
250
{
 
251
    ASSERT(!RunLoop::isMain());
 
252
 
 
253
    LockHolder locker(m_server->lock());
 
254
    m_server->openCursor(requestData, cursorInfo);
 
255
}
 
256
 
 
257
void WebIDBServer::iterateCursor(const WebCore::IDBRequestData& requestData, const WebCore::IDBIterateCursorData& iterateCursorData)
 
258
{
 
259
    ASSERT(!RunLoop::isMain());
 
260
 
 
261
    LockHolder locker(m_server->lock());
 
262
    m_server->iterateCursor(requestData, iterateCursorData);
 
263
}
 
264
 
 
265
void WebIDBServer::establishTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBTransactionInfo& transactionInfo)
 
266
{
 
267
    ASSERT(!RunLoop::isMain());
 
268
 
 
269
    LockHolder locker(m_server->lock());
 
270
    m_server->establishTransaction(databaseConnectionIdentifier, transactionInfo);
 
271
}
 
272
 
 
273
void WebIDBServer::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
 
274
{
 
275
    ASSERT(!RunLoop::isMain());
 
276
 
 
277
    LockHolder locker(m_server->lock());
 
278
    m_server->databaseConnectionPendingClose(databaseConnectionIdentifier);
 
279
}
 
280
 
 
281
void WebIDBServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
 
282
{
 
283
    ASSERT(!RunLoop::isMain());
 
284
 
 
285
    LockHolder locker(m_server->lock());
 
286
    m_server->databaseConnectionClosed(databaseConnectionIdentifier);
 
287
}
 
288
 
 
289
void WebIDBServer::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier)
 
290
{
 
291
    ASSERT(!RunLoop::isMain());
 
292
 
 
293
    LockHolder locker(m_server->lock());
 
294
    m_server->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
 
295
}
 
296
 
 
297
void WebIDBServer::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier, WebCore::IndexedDB::ConnectionClosedOnBehalfOfServer connectionClosed)
 
298
{
 
299
    ASSERT(!RunLoop::isMain());
 
300
 
 
301
    LockHolder locker(m_server->lock());
 
302
    m_server->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, connectionClosed);
 
303
}
 
304
 
 
305
void WebIDBServer::openDBRequestCancelled(const WebCore::IDBRequestData& requestData)
 
306
{
 
307
    ASSERT(!RunLoop::isMain());
 
308
 
 
309
    LockHolder locker(m_server->lock());
 
310
    m_server->openDBRequestCancelled(requestData);
 
311
}
 
312
 
 
313
void WebIDBServer::getAllDatabaseNames(IPC::Connection& connection, const WebCore::SecurityOriginData& mainFrameOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID)
 
314
{
 
315
    ASSERT(!RunLoop::isMain());
 
316
 
 
317
    auto* webIDBConnection = m_connectionMap.get(connection.uniqueID());
 
318
    ASSERT(webIDBConnection);
 
319
 
 
320
    LockHolder locker(m_server->lock());
 
321
    m_server->getAllDatabaseNames(webIDBConnection->identifier(), mainFrameOrigin, openingOrigin, callbackID);
 
322
}
 
323
 
 
324
void WebIDBServer::addConnection(IPC::Connection& connection, WebCore::ProcessIdentifier processIdentifier)
 
325
{
 
326
    ASSERT(RunLoop::isMain());
 
327
 
 
328
    postTask([this, protectedThis = makeRef(*this), protectedConnection = makeRefPtr(connection), processIdentifier] {
 
329
        auto[iter, isNewEntry] = m_connectionMap.ensure(protectedConnection->uniqueID(), [&] {
 
330
            return makeUnique<WebIDBConnectionToClient>(*protectedConnection, processIdentifier);
 
331
        });
 
332
 
 
333
        ASSERT_UNUSED(isNewEntry, isNewEntry);
 
334
 
 
335
        LockHolder locker(m_server->lock());
 
336
        m_server->registerConnection(iter->value->connectionToClient());
 
337
    });
 
338
    connection.addThreadMessageReceiver(Messages::WebIDBServer::messageReceiverName(), this);
 
339
}
 
340
 
 
341
void WebIDBServer::removeConnection(IPC::Connection& connection)
 
342
{
 
343
    ASSERT(RunLoop::isMain());
 
344
 
 
345
    connection.removeThreadMessageReceiver(Messages::WebIDBServer::messageReceiverName());
 
346
    postTask([this, protectedThis = makeRef(*this), connectionID = connection.uniqueID()] {
 
347
        auto connection = m_connectionMap.take(connectionID);
 
348
 
 
349
        ASSERT(connection);
 
350
 
 
351
        LockHolder locker(m_server->lock());
 
352
        m_server->unregisterConnection(connection->connectionToClient());
 
353
    });
 
354
}
 
355
 
 
356
void WebIDBServer::postTask(Function<void()>&& task)
 
357
{
 
358
    ASSERT(RunLoop::isMain());
 
359
 
 
360
    CrossThreadTaskHandler::postTask(CrossThreadTask(WTFMove(task)));
 
361
}
 
362
 
 
363
void WebIDBServer::dispatchToThread(Function<void()>&& task)
 
364
{
 
365
    CrossThreadTaskHandler::postTask(CrossThreadTask(WTFMove(task)));
 
366
}
 
367
 
 
368
} // namespace WebKit
 
369
#endif