Add a new Logging Channel for IndexedDB Operation scheduling.
[WebKit.git] / Source / WebCore / Modules / indexeddb / IDBDatabase.cpp
1 /*
2  * Copyright (C) 2015, 2016 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 "IDBDatabase.h"
28
29 #if ENABLE(INDEXED_DATABASE)
30
31 #include "DOMStringList.h"
32 #include "EventNames.h"
33 #include "EventQueue.h"
34 #include "ExceptionCode.h"
35 #include "IDBConnectionProxy.h"
36 #include "IDBConnectionToServer.h"
37 #include "IDBDatabaseException.h"
38 #include "IDBIndex.h"
39 #include "IDBObjectStore.h"
40 #include "IDBOpenDBRequest.h"
41 #include "IDBResultData.h"
42 #include "IDBTransaction.h"
43 #include "IDBVersionChangeEvent.h"
44 #include "Logging.h"
45 #include "ScriptExecutionContext.h"
46 #include <heap/HeapInlines.h>
47
48 namespace WebCore {
49
50 Ref<IDBDatabase> IDBDatabase::create(ScriptExecutionContext& context, IDBClient::IDBConnectionProxy& connectionProxy, const IDBResultData& resultData)
51 {
52     return adoptRef(*new IDBDatabase(context, connectionProxy, resultData));
53 }
54
55 IDBDatabase::IDBDatabase(ScriptExecutionContext& context, IDBClient::IDBConnectionProxy& connectionProxy, const IDBResultData& resultData)
56     : IDBActiveDOMObject(&context)
57     , m_connectionProxy(connectionProxy)
58     , m_info(resultData.databaseInfo())
59     , m_databaseConnectionIdentifier(resultData.databaseConnectionIdentifier())
60     , m_eventNames(eventNames())
61 {
62     LOG(IndexedDB, "IDBDatabase::IDBDatabase - Creating database %s with version %" PRIu64 " connection %" PRIu64 " (%p)", m_info.name().utf8().data(), m_info.version(), m_databaseConnectionIdentifier, this);
63     suspendIfNeeded();
64     m_connectionProxy->registerDatabaseConnection(*this);
65 }
66
67 IDBDatabase::~IDBDatabase()
68 {
69     ASSERT(currentThread() == originThreadID());
70
71     if (!m_closedInServer)
72         m_connectionProxy->databaseConnectionClosed(*this);
73
74     m_connectionProxy->unregisterDatabaseConnection(*this);
75 }
76
77 bool IDBDatabase::hasPendingActivity() const
78 {
79     ASSERT(currentThread() == originThreadID() || mayBeGCThread());
80
81     if (m_closedInServer)
82         return false;
83
84     if (!m_activeTransactions.isEmpty() || !m_committingTransactions.isEmpty() || !m_abortingTransactions.isEmpty())
85         return true;
86
87     return hasEventListeners(m_eventNames.abortEvent) || hasEventListeners(m_eventNames.errorEvent) || hasEventListeners(m_eventNames.versionchangeEvent);
88 }
89
90 const String IDBDatabase::name() const
91 {
92     ASSERT(currentThread() == originThreadID());
93     return m_info.name();
94 }
95
96 uint64_t IDBDatabase::version() const
97 {
98     ASSERT(currentThread() == originThreadID());
99     return m_info.version();
100 }
101
102 RefPtr<DOMStringList> IDBDatabase::objectStoreNames() const
103 {
104     ASSERT(currentThread() == originThreadID());
105
106     RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
107     for (auto& name : m_info.objectStoreNames())
108         objectStoreNames->append(name);
109     objectStoreNames->sort();
110     return objectStoreNames;
111 }
112
113 void IDBDatabase::renameObjectStore(IDBObjectStore& objectStore, const String& newName)
114 {
115     ASSERT(currentThread() == originThreadID());
116     ASSERT(m_versionChangeTransaction);
117     ASSERT(m_info.hasObjectStore(objectStore.info().name()));
118
119     m_info.renameObjectStore(objectStore.info().identifier(), newName);
120
121     m_versionChangeTransaction->renameObjectStore(objectStore, newName);
122 }
123
124 void IDBDatabase::renameIndex(IDBIndex& index, const String& newName)
125 {
126     ASSERT(currentThread() == originThreadID());
127     ASSERT(m_versionChangeTransaction);
128     ASSERT(m_info.hasObjectStore(index.objectStore().info().name()));
129     ASSERT(m_info.infoForExistingObjectStore(index.objectStore().info().name())->hasIndex(index.info().name()));
130
131     m_info.infoForExistingObjectStore(index.objectStore().info().name())->infoForExistingIndex(index.info().identifier())->rename(newName);
132
133     m_versionChangeTransaction->renameIndex(index, newName);
134 }
135
136 ExceptionOr<Ref<IDBObjectStore>> IDBDatabase::createObjectStore(const String& name, ObjectStoreParameters&& parameters)
137 {
138     LOG(IndexedDB, "IDBDatabase::createObjectStore - (%s %s)", m_info.name().utf8().data(), name.utf8().data());
139
140     ASSERT(currentThread() == originThreadID());
141     ASSERT(!m_versionChangeTransaction || m_versionChangeTransaction->isVersionChange());
142
143     if (!m_versionChangeTransaction)
144         return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The database is not running a version change transaction.") };
145
146     if (!m_versionChangeTransaction->isActive())
147         return Exception { IDBDatabaseException::TransactionInactiveError };
148
149     if (m_info.hasObjectStore(name))
150         return Exception { IDBDatabaseException::ConstraintError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': An object store with the specified name already exists.") };
151
152     auto& keyPath = parameters.keyPath;
153     if (keyPath && !isIDBKeyPathValid(keyPath.value()))
154         return Exception { IDBDatabaseException::SyntaxError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The keyPath option is not a valid key path.") };
155
156     if (keyPath && parameters.autoIncrement && ((WTF::holds_alternative<String>(keyPath.value()) && WTF::get<String>(keyPath.value()).isEmpty()) || WTF::holds_alternative<Vector<String>>(keyPath.value())))
157         return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The autoIncrement option was set but the keyPath option was empty or an array.") };
158
159     // Install the new ObjectStore into the connection's metadata.
160     auto info = m_info.createNewObjectStore(name, WTFMove(keyPath), parameters.autoIncrement);
161
162     // Create the actual IDBObjectStore from the transaction, which also schedules the operation server side.
163     return m_versionChangeTransaction->createObjectStore(info);
164 }
165
166 ExceptionOr<Ref<IDBTransaction>> IDBDatabase::transaction(StringOrVectorOfStrings&& storeNames, IDBTransactionMode mode)
167 {
168     LOG(IndexedDB, "IDBDatabase::transaction");
169
170     ASSERT(currentThread() == originThreadID());
171
172     if (m_closePending)
173         return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The database connection is closing.") };
174
175     Vector<String> objectStores;
176     if (WTF::holds_alternative<Vector<String>>(storeNames))
177         objectStores = WTFMove(WTF::get<Vector<String>>(storeNames));
178     else
179         objectStores.append(WTFMove(WTF::get<String>(storeNames)));
180
181     if (objectStores.isEmpty())
182         return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The storeNames parameter was empty.") };
183
184     if (mode != IDBTransactionMode::Readonly && mode != IDBTransactionMode::Readwrite)
185         return Exception { TypeError };
186
187     if (m_versionChangeTransaction && !m_versionChangeTransaction->isFinishedOrFinishing())
188         return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': A version change transaction is running.") };
189
190     // It is valid for javascript to pass in a list of object store names with the same name listed twice,
191     // so we need to put them all in a set to get a unique list.
192     HashSet<String> objectStoreSet;
193     for (auto& objectStore : objectStores)
194         objectStoreSet.add(objectStore);
195
196     objectStores.clear();
197     copyToVector(objectStoreSet, objectStores);
198
199     for (auto& objectStoreName : objectStores) {
200         if (m_info.hasObjectStore(objectStoreName))
201             continue;
202         return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': One of the specified object stores was not found.") };
203     }
204
205     auto info = IDBTransactionInfo::clientTransaction(m_connectionProxy.get(), objectStores, mode);
206
207     LOG(IndexedDBOperations, "IDB creating transaction: %s", info.loggingString().utf8().data());
208     auto transaction = IDBTransaction::create(*this, info);
209
210     LOG(IndexedDB, "IDBDatabase::transaction - Added active transaction %s", info.identifier().loggingString().utf8().data());
211
212     m_activeTransactions.set(info.identifier(), transaction.ptr());
213
214     return WTFMove(transaction);
215 }
216
217 ExceptionOr<void> IDBDatabase::deleteObjectStore(const String& objectStoreName)
218 {
219     LOG(IndexedDB, "IDBDatabase::deleteObjectStore");
220
221     ASSERT(currentThread() == originThreadID());
222
223     if (!m_versionChangeTransaction)
224         return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The database is not running a version change transaction.") };
225
226     if (!m_versionChangeTransaction->isActive())
227         return Exception { IDBDatabaseException::TransactionInactiveError };
228
229     if (!m_info.hasObjectStore(objectStoreName))
230         return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The specified object store was not found.") };
231
232     m_info.deleteObjectStore(objectStoreName);
233     m_versionChangeTransaction->deleteObjectStore(objectStoreName);
234
235     return { };
236 }
237
238 void IDBDatabase::close()
239 {
240     LOG(IndexedDB, "IDBDatabase::close - %" PRIu64, m_databaseConnectionIdentifier);
241
242     ASSERT(currentThread() == originThreadID());
243
244     if (!m_closePending) {
245         m_closePending = true;
246         m_connectionProxy->databaseConnectionPendingClose(*this);
247     }
248
249     maybeCloseInServer();
250 }
251
252 void IDBDatabase::didCloseFromServer(const IDBError& error)
253 {
254     LOG(IndexedDB, "IDBDatabase::didCloseFromServer - %" PRIu64, m_databaseConnectionIdentifier);
255
256     connectionToServerLost(error);
257
258     m_connectionProxy->confirmDidCloseFromServer(*this);
259 }
260
261 void IDBDatabase::connectionToServerLost(const IDBError& error)
262 {
263     LOG(IndexedDB, "IDBDatabase::connectionToServerLost - %" PRIu64, m_databaseConnectionIdentifier);
264
265     ASSERT(currentThread() == originThreadID());
266
267     m_closePending = true;
268     m_closedInServer = true;
269
270     for (auto& transaction : m_activeTransactions.values())
271         transaction->connectionClosedFromServer(error);
272
273     auto errorEvent = Event::create(m_eventNames.errorEvent, true, false);
274     errorEvent->setTarget(this);
275
276     if (auto* context = scriptExecutionContext())
277         context->eventQueue().enqueueEvent(WTFMove(errorEvent));
278
279     auto closeEvent = Event::create(m_eventNames.closeEvent, true, false);
280     closeEvent->setTarget(this);
281
282     if (auto* context = scriptExecutionContext())
283         context->eventQueue().enqueueEvent(WTFMove(closeEvent));
284 }
285
286 void IDBDatabase::maybeCloseInServer()
287 {
288     LOG(IndexedDB, "IDBDatabase::maybeCloseInServer - %" PRIu64, m_databaseConnectionIdentifier);
289
290     ASSERT(currentThread() == originThreadID());
291
292     if (m_closedInServer)
293         return;
294
295     // 3.3.9 Database closing steps
296     // Wait for all transactions created using this connection to complete.
297     // Once they are complete, this connection is closed.
298     if (!m_activeTransactions.isEmpty() || !m_committingTransactions.isEmpty())
299         return;
300
301     m_closedInServer = true;
302     m_connectionProxy->databaseConnectionClosed(*this);
303 }
304
305 const char* IDBDatabase::activeDOMObjectName() const
306 {
307     ASSERT(currentThread() == originThreadID());
308     return "IDBDatabase";
309 }
310
311 bool IDBDatabase::canSuspendForDocumentSuspension() const
312 {
313     ASSERT(currentThread() == originThreadID());
314
315     // FIXME: This value will sometimes be false when database operations are actually in progress.
316     // Such database operations do not yet exist.
317     return true;
318 }
319
320 void IDBDatabase::stop()
321 {
322     LOG(IndexedDB, "IDBDatabase::stop - %" PRIu64, m_databaseConnectionIdentifier);
323
324     ASSERT(currentThread() == originThreadID());
325
326     removeAllEventListeners();
327
328     Vector<IDBResourceIdentifier> transactionIdentifiers;
329     transactionIdentifiers.reserveInitialCapacity(m_activeTransactions.size());
330
331     for (auto& id : m_activeTransactions.keys())
332         transactionIdentifiers.uncheckedAppend(id);
333
334     for (auto& id : transactionIdentifiers) {
335         IDBTransaction* transaction = m_activeTransactions.get(id);
336         if (transaction)
337             transaction->stop();
338     }
339
340     close();
341 }
342
343 Ref<IDBTransaction> IDBDatabase::startVersionChangeTransaction(const IDBTransactionInfo& info, IDBOpenDBRequest& request)
344 {
345     LOG(IndexedDB, "IDBDatabase::startVersionChangeTransaction %s", info.identifier().loggingString().utf8().data());
346
347     ASSERT(currentThread() == originThreadID());
348     ASSERT(!m_versionChangeTransaction);
349     ASSERT(info.mode() == IDBTransactionMode::Versionchange);
350     ASSERT(!m_closePending);
351     ASSERT(scriptExecutionContext());
352
353     Ref<IDBTransaction> transaction = IDBTransaction::create(*this, info, request);
354     m_versionChangeTransaction = &transaction.get();
355
356     m_activeTransactions.set(transaction->info().identifier(), &transaction.get());
357
358     return transaction;
359 }
360
361 void IDBDatabase::didStartTransaction(IDBTransaction& transaction)
362 {
363     LOG(IndexedDB, "IDBDatabase::didStartTransaction %s", transaction.info().identifier().loggingString().utf8().data());
364     ASSERT(!m_versionChangeTransaction);
365     ASSERT(currentThread() == originThreadID());
366
367     // It is possible for the client to have aborted a transaction before the server replies back that it has started.
368     if (m_abortingTransactions.contains(transaction.info().identifier()))
369         return;
370
371     m_activeTransactions.set(transaction.info().identifier(), &transaction);
372 }
373
374 void IDBDatabase::willCommitTransaction(IDBTransaction& transaction)
375 {
376     LOG(IndexedDB, "IDBDatabase::willCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data());
377
378     ASSERT(currentThread() == originThreadID());
379
380     auto refTransaction = m_activeTransactions.take(transaction.info().identifier());
381     ASSERT(refTransaction);
382     m_committingTransactions.set(transaction.info().identifier(), WTFMove(refTransaction));
383 }
384
385 void IDBDatabase::didCommitTransaction(IDBTransaction& transaction)
386 {
387     LOG(IndexedDB, "IDBDatabase::didCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data());
388
389     ASSERT(currentThread() == originThreadID());
390
391     if (m_versionChangeTransaction == &transaction)
392         m_info.setVersion(transaction.info().newVersion());
393
394     didCommitOrAbortTransaction(transaction);
395 }
396
397 void IDBDatabase::willAbortTransaction(IDBTransaction& transaction)
398 {
399     LOG(IndexedDB, "IDBDatabase::willAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
400
401     ASSERT(currentThread() == originThreadID());
402
403     auto refTransaction = m_activeTransactions.take(transaction.info().identifier());
404     if (!refTransaction)
405         refTransaction = m_committingTransactions.take(transaction.info().identifier());
406
407     ASSERT(refTransaction);
408     m_abortingTransactions.set(transaction.info().identifier(), WTFMove(refTransaction));
409
410     if (transaction.isVersionChange()) {
411         ASSERT(transaction.originalDatabaseInfo());
412         m_info = *transaction.originalDatabaseInfo();
413         m_closePending = true;
414     }
415 }
416
417 void IDBDatabase::didAbortTransaction(IDBTransaction& transaction)
418 {
419     LOG(IndexedDB, "IDBDatabase::didAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
420
421     ASSERT(currentThread() == originThreadID());
422
423     if (transaction.isVersionChange()) {
424         ASSERT(transaction.originalDatabaseInfo());
425         ASSERT(m_info.version() == transaction.originalDatabaseInfo()->version());
426         m_closePending = true;
427         maybeCloseInServer();
428     }
429
430     didCommitOrAbortTransaction(transaction);
431 }
432
433 void IDBDatabase::didCommitOrAbortTransaction(IDBTransaction& transaction)
434 {
435     LOG(IndexedDB, "IDBDatabase::didCommitOrAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
436
437     ASSERT(currentThread() == originThreadID());
438
439     if (m_versionChangeTransaction == &transaction)
440         m_versionChangeTransaction = nullptr;
441
442 #ifndef NDBEBUG
443     unsigned count = 0;
444     if (m_activeTransactions.contains(transaction.info().identifier()))
445         ++count;
446     if (m_committingTransactions.contains(transaction.info().identifier()))
447         ++count;
448     if (m_abortingTransactions.contains(transaction.info().identifier()))
449         ++count;
450
451     ASSERT(count == 1);
452 #endif
453
454     m_activeTransactions.remove(transaction.info().identifier());
455     m_committingTransactions.remove(transaction.info().identifier());
456     m_abortingTransactions.remove(transaction.info().identifier());
457
458     if (m_closePending)
459         maybeCloseInServer();
460 }
461
462 void IDBDatabase::fireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
463 {
464     uint64_t currentVersion = m_info.version();
465     LOG(IndexedDB, "IDBDatabase::fireVersionChangeEvent - current version %" PRIu64 ", requested version %" PRIu64 ", connection %" PRIu64 " (%p)", currentVersion, requestedVersion, m_databaseConnectionIdentifier, this);
466
467     ASSERT(currentThread() == originThreadID());
468
469     if (!scriptExecutionContext() || m_closePending) {
470         connectionProxy().didFireVersionChangeEvent(m_databaseConnectionIdentifier, requestIdentifier);
471         return;
472     }
473     
474     Ref<Event> event = IDBVersionChangeEvent::create(requestIdentifier, currentVersion, requestedVersion, m_eventNames.versionchangeEvent);
475     event->setTarget(this);
476     scriptExecutionContext()->eventQueue().enqueueEvent(WTFMove(event));
477 }
478
479 bool IDBDatabase::dispatchEvent(Event& event)
480 {
481     LOG(IndexedDB, "IDBDatabase::dispatchEvent (%" PRIu64 ") (%p)", m_databaseConnectionIdentifier, this);
482     ASSERT(currentThread() == originThreadID());
483
484     bool result = EventTargetWithInlineData::dispatchEvent(event);
485
486     if (event.isVersionChangeEvent() && event.type() == m_eventNames.versionchangeEvent)
487         connectionProxy().didFireVersionChangeEvent(m_databaseConnectionIdentifier, downcast<IDBVersionChangeEvent>(event).requestIdentifier());
488
489     return result;
490 }
491
492 void IDBDatabase::didCreateIndexInfo(const IDBIndexInfo& info)
493 {
494     ASSERT(currentThread() == originThreadID());
495
496     auto* objectStore = m_info.infoForExistingObjectStore(info.objectStoreIdentifier());
497     ASSERT(objectStore);
498     objectStore->addExistingIndex(info);
499 }
500
501 void IDBDatabase::didDeleteIndexInfo(const IDBIndexInfo& info)
502 {
503     ASSERT(currentThread() == originThreadID());
504
505     auto* objectStore = m_info.infoForExistingObjectStore(info.objectStoreIdentifier());
506     ASSERT(objectStore);
507     objectStore->deleteIndex(info.name());
508 }
509
510 } // namespace WebCore
511
512 #endif // ENABLE(INDEXED_DATABASE)