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