src/third_party/WebKit/Source/modules/indexeddb/IDBDatabase.cpp

   1 /*
   2  * Copyright (C) 2010 Google 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  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "modules/indexeddb/IDBDatabase.h"
  28
  29 #include "bindings/core/v8/ExceptionState.h"
  30 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
  31 #include "bindings/core/v8/Nullable.h"
  32 #include "bindings/core/v8/SerializedScriptValue.h"
  33 #include "bindings/modules/v8/IDBBindingUtilities.h"
  34 #include "core/dom/ExecutionContext.h"
  35 #include "core/events/EventQueue.h"
  36 #include "core/inspector/ScriptCallStack.h"
  37 #include "modules/indexeddb/IDBAny.h"
  38 #include "modules/indexeddb/IDBEventDispatcher.h"
  39 #include "modules/indexeddb/IDBHistograms.h"
  40 #include "modules/indexeddb/IDBIndex.h"
  41 #include "modules/indexeddb/IDBKeyPath.h"
  42 #include "modules/indexeddb/IDBTracing.h"
  43 #include "modules/indexeddb/IDBVersionChangeEvent.h"
  44 #include "modules/indexeddb/WebIDBDatabaseCallbacksImpl.h"
  45 #include "public/platform/Platform.h"
  46 #include "public/platform/WebIDBKeyPath.h"
  47 #include "public/platform/WebIDBTypes.h"
  48 #include "wtf/Atomics.h"
  49 #include <limits>
  50
  51 using blink::WebIDBDatabase;
  52
  53 namespace blink {
  54
  55 const char IDBDatabase::indexDeletedErrorMessage[] = "The index or its object store has been deleted.";
  56 const char IDBDatabase::isKeyCursorErrorMessage[] = "The cursor is a key cursor.";
  57 const char IDBDatabase::noKeyOrKeyRangeErrorMessage[] = "No key or key range specified.";
  58 const char IDBDatabase::noSuchIndexErrorMessage[] = "The specified index was not found.";
  59 const char IDBDatabase::noSuchObjectStoreErrorMessage[] = "The specified object store was not found.";
  60 const char IDBDatabase::noValueErrorMessage[] = "The cursor is being iterated or has iterated past its end.";
  61 const char IDBDatabase::notValidKeyErrorMessage[] = "The parameter is not a valid key.";
  62 const char IDBDatabase::notVersionChangeTransactionErrorMessage[] = "The database is not running a version change transaction.";
  63 const char IDBDatabase::objectStoreDeletedErrorMessage[] = "The object store has been deleted.";
  64 const char IDBDatabase::requestNotFinishedErrorMessage[] = "The request has not finished.";
  65 const char IDBDatabase::sourceDeletedErrorMessage[] = "The cursor's source or effective object store has been deleted.";
  66 const char IDBDatabase::transactionInactiveErrorMessage[] = "The transaction is not active.";
  67 const char IDBDatabase::transactionFinishedErrorMessage[] = "The transaction has finished.";
  68 const char IDBDatabase::transactionReadOnlyErrorMessage[] = "The transaction is read-only.";
  69 const char IDBDatabase::databaseClosedErrorMessage[] = "The database connection is closed.";
  70
  71 IDBDatabase* IDBDatabase::create(ExecutionContext* context, PassOwnPtr<WebIDBDatabase> database, IDBDatabaseCallbacks* callbacks)
  72 {
  73     IDBDatabase* idbDatabase = adoptRefCountedGarbageCollectedWillBeNoop(new IDBDatabase(context, database, callbacks));
  74     idbDatabase->suspendIfNeeded();
  75     return idbDatabase;
  76 }
  77
  78 IDBDatabase::IDBDatabase(ExecutionContext* context, PassOwnPtr<WebIDBDatabase> backend, IDBDatabaseCallbacks* callbacks)
  79     : ActiveDOMObject(context)
  80     , m_backend(backend)
  81     , m_closePending(false)
  82     , m_contextStopped(false)
  83     , m_databaseCallbacks(callbacks)
  84 {
  85     m_databaseCallbacks->connect(this);
  86 }
  87
  88 IDBDatabase::~IDBDatabase()
  89 {
  90     if (!m_closePending && m_backend)
  91         m_backend->close();
  92 }
  93
  94 void IDBDatabase::trace(Visitor* visitor)
  95 {
  96     visitor->trace(m_versionChangeTransaction);
  97     visitor->trace(m_transactions);
  98 #if ENABLE(OILPAN)
  99     visitor->trace(m_enqueuedEvents);
 100 #endif
 101     visitor->trace(m_databaseCallbacks);
 102     EventTargetWithInlineData::trace(visitor);
 103 }
 104
 105 int64_t IDBDatabase::nextTransactionId()
 106 {
 107     // Only keep a 32-bit counter to allow ports to use the other 32
 108     // bits of the id.
 109     AtomicallyInitializedStatic(int, currentTransactionId = 0);
 110     return atomicIncrement(&currentTransactionId);
 111 }
 112
 113 void IDBDatabase::ackReceivedBlobs(const Vector<WebBlobInfo>* blobInfo)
 114 {
 115     ASSERT(blobInfo);
 116     if (!blobInfo->size() || !m_backend)
 117         return;
 118     Vector<WebBlobInfo>::const_iterator iter;
 119     Vector<String> uuids;
 120     uuids.reserveCapacity(blobInfo->size());
 121     for (iter = blobInfo->begin(); iter != blobInfo->end(); ++iter)
 122         uuids.append(iter->uuid());
 123     m_backend->ackReceivedBlobs(uuids);
 124 }
 125
 126 void IDBDatabase::indexCreated(int64_t objectStoreId, const IDBIndexMetadata& metadata)
 127 {
 128     IDBDatabaseMetadata::ObjectStoreMap::iterator it = m_metadata.objectStores.find(objectStoreId);
 129     ASSERT_WITH_SECURITY_IMPLICATION(it != m_metadata.objectStores.end());
 130     it->value.indexes.set(metadata.id, metadata);
 131 }
 132
 133 void IDBDatabase::indexDeleted(int64_t objectStoreId, int64_t indexId)
 134 {
 135     IDBDatabaseMetadata::ObjectStoreMap::iterator it = m_metadata.objectStores.find(objectStoreId);
 136     ASSERT_WITH_SECURITY_IMPLICATION(it != m_metadata.objectStores.end());
 137     it->value.indexes.remove(indexId);
 138 }
 139
 140 void IDBDatabase::transactionCreated(IDBTransaction* transaction)
 141 {
 142     ASSERT(transaction);
 143     ASSERT(!m_transactions.contains(transaction->id()));
 144     m_transactions.add(transaction->id(), transaction);
 145
 146     if (transaction->isVersionChange()) {
 147         ASSERT(!m_versionChangeTransaction);
 148         m_versionChangeTransaction = transaction;
 149     }
 150 }
 151
 152 void IDBDatabase::transactionFinished(const IDBTransaction* transaction)
 153 {
 154     ASSERT(transaction);
 155     ASSERT(m_transactions.contains(transaction->id()));
 156     ASSERT(m_transactions.get(transaction->id()) == transaction);
 157     m_transactions.remove(transaction->id());
 158
 159     if (transaction->isVersionChange()) {
 160         ASSERT(m_versionChangeTransaction == transaction);
 161         m_versionChangeTransaction = nullptr;
 162     }
 163
 164     if (m_closePending && m_transactions.isEmpty())
 165         closeConnection();
 166 }
 167
 168 void IDBDatabase::onAbort(int64_t transactionId, PassRefPtrWillBeRawPtr<DOMError> error)
 169 {
 170     ASSERT(m_transactions.contains(transactionId));
 171     m_transactions.get(transactionId)->onAbort(error);
 172 }
 173
 174 void IDBDatabase::onComplete(int64_t transactionId)
 175 {
 176     ASSERT(m_transactions.contains(transactionId));
 177     m_transactions.get(transactionId)->onComplete();
 178 }
 179
 180 PassRefPtrWillBeRawPtr<DOMStringList> IDBDatabase::objectStoreNames() const
 181 {
 182     RefPtrWillBeRawPtr<DOMStringList> objectStoreNames = DOMStringList::create();
 183     for (IDBDatabaseMetadata::ObjectStoreMap::const_iterator it = m_metadata.objectStores.begin(); it != m_metadata.objectStores.end(); ++it)
 184         objectStoreNames->append(it->value.name);
 185     objectStoreNames->sort();
 186     return objectStoreNames.release();
 187 }
 188
 189 ScriptValue IDBDatabase::version(ScriptState* scriptState) const
 190 {
 191     int64_t intVersion = m_metadata.intVersion;
 192     if (intVersion == IDBDatabaseMetadata::NoIntVersion)
 193         return idbAnyToScriptValue(scriptState, IDBAny::createString(m_metadata.version));
 194
 195     return idbAnyToScriptValue(scriptState, IDBAny::create(intVersion));
 196 }
 197
 198 IDBObjectStore* IDBDatabase::createObjectStore(const String& name, const Dictionary& options, ExceptionState& exceptionState)
 199 {
 200     IDBKeyPath keyPath;
 201     bool autoIncrement = false;
 202     if (!options.isUndefinedOrNull()) {
 203         String keyPathString;
 204         Vector<String> keyPathArray;
 205         if (DictionaryHelper::get(options, "keyPath", keyPathArray))
 206             keyPath = IDBKeyPath(keyPathArray);
 207         else if (options.getWithUndefinedOrNullCheck("keyPath", keyPathString))
 208             keyPath = IDBKeyPath(keyPathString);
 209
 210         DictionaryHelper::get(options, "autoIncrement", autoIncrement);
 211     }
 212
 213     return createObjectStore(name, keyPath, autoIncrement, exceptionState);
 214 }
 215
 216 IDBObjectStore* IDBDatabase::createObjectStore(const String& name, const IDBKeyPath& keyPath, bool autoIncrement, ExceptionState& exceptionState)
 217 {
 218     IDB_TRACE("IDBDatabase::createObjectStore");
 219     Platform::current()->histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBCreateObjectStoreCall, IDBMethodsMax);
 220     if (!m_versionChangeTransaction) {
 221         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
 222         return 0;
 223     }
 224     if (m_versionChangeTransaction->isFinished() || m_versionChangeTransaction->isFinishing()) {
 225         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
 226         return 0;
 227     }
 228     if (!m_versionChangeTransaction->isActive()) {
 229         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
 230         return 0;
 231     }
 232
 233     if (containsObjectStore(name)) {
 234         exceptionState.throwDOMException(ConstraintError, "An object store with the specified name already exists.");
 235         return 0;
 236     }
 237
 238     if (!keyPath.isNull() && !keyPath.isValid()) {
 239         exceptionState.throwDOMException(SyntaxError, "The keyPath option is not a valid key path.");
 240         return 0;
 241     }
 242
 243     if (autoIncrement && ((keyPath.type() == IDBKeyPath::StringType && keyPath.string().isEmpty()) || keyPath.type() == IDBKeyPath::ArrayType)) {
 244         exceptionState.throwDOMException(InvalidAccessError, "The autoIncrement option was set but the keyPath option was empty or an array.");
 245         return 0;
 246     }
 247
 248     if (!m_backend) {
 249         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
 250         return 0;
 251     }
 252
 253     int64_t objectStoreId = m_metadata.maxObjectStoreId + 1;
 254     m_backend->createObjectStore(m_versionChangeTransaction->id(), objectStoreId, name, keyPath, autoIncrement);
 255
 256     IDBObjectStoreMetadata metadata(name, objectStoreId, keyPath, autoIncrement, WebIDBDatabase::minimumIndexId);
 257     IDBObjectStore* objectStore = IDBObjectStore::create(metadata, m_versionChangeTransaction.get());
 258     m_metadata.objectStores.set(metadata.id, metadata);
 259     ++m_metadata.maxObjectStoreId;
 260
 261     m_versionChangeTransaction->objectStoreCreated(name, objectStore);
 262     return objectStore;
 263 }
 264
 265 void IDBDatabase::deleteObjectStore(const String& name, ExceptionState& exceptionState)
 266 {
 267     IDB_TRACE("IDBDatabase::deleteObjectStore");
 268     Platform::current()->histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBDeleteObjectStoreCall, IDBMethodsMax);
 269     if (!m_versionChangeTransaction) {
 270         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
 271         return;
 272     }
 273     if (m_versionChangeTransaction->isFinished() || m_versionChangeTransaction->isFinishing()) {
 274         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
 275         return;
 276     }
 277     if (!m_versionChangeTransaction->isActive()) {
 278         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
 279         return;
 280     }
 281
 282     int64_t objectStoreId = findObjectStoreId(name);
 283     if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
 284         exceptionState.throwDOMException(NotFoundError, "The specified object store was not found.");
 285         return;
 286     }
 287
 288     if (!m_backend) {
 289         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
 290         return;
 291     }
 292
 293     m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);
 294     m_versionChangeTransaction->objectStoreDeleted(name);
 295     m_metadata.objectStores.remove(objectStoreId);
 296 }
 297
 298 IDBTransaction* IDBDatabase::transaction(ScriptState* scriptState, const Vector<String>& scope, const String& modeString, ExceptionState& exceptionState)
 299 {
 300     IDB_TRACE("IDBDatabase::transaction");
 301     Platform::current()->histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBTransactionCall, IDBMethodsMax);
 302     if (!scope.size()) {
 303         exceptionState.throwDOMException(InvalidAccessError, "The storeNames parameter was empty.");
 304         return 0;
 305     }
 306
 307     WebIDBTransactionMode mode = IDBTransaction::stringToMode(modeString, exceptionState);
 308     if (exceptionState.hadException())
 309         return 0;
 310
 311     if (m_versionChangeTransaction) {
 312         exceptionState.throwDOMException(InvalidStateError, "A version change transaction is running.");
 313         return 0;
 314     }
 315
 316     if (m_closePending) {
 317         exceptionState.throwDOMException(InvalidStateError, "The database connection is closing.");
 318         return 0;
 319     }
 320
 321     Vector<int64_t> objectStoreIds;
 322     for (size_t i = 0; i < scope.size(); ++i) {
 323         int64_t objectStoreId = findObjectStoreId(scope[i]);
 324         if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
 325             exceptionState.throwDOMException(NotFoundError, "One of the specified object stores was not found.");
 326             return 0;
 327         }
 328         objectStoreIds.append(objectStoreId);
 329     }
 330
 331     if (!m_backend) {
 332         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
 333         return 0;
 334     }
 335
 336     int64_t transactionId = nextTransactionId();
 337     m_backend->createTransaction(transactionId, WebIDBDatabaseCallbacksImpl::create(m_databaseCallbacks).leakPtr(), objectStoreIds, mode);
 338
 339     return IDBTransaction::create(scriptState, transactionId, scope, mode, this);
 340 }
 341
 342 IDBTransaction* IDBDatabase::transaction(ScriptState* scriptState, const String& storeName, const String& mode, ExceptionState& exceptionState)
 343 {
 344     RefPtrWillBeRawPtr<DOMStringList> storeNames = DOMStringList::create();
 345     storeNames->append(storeName);
 346     return transaction(scriptState, storeNames, mode, exceptionState);
 347 }
 348
 349 void IDBDatabase::forceClose()
 350 {
 351     for (TransactionMap::const_iterator::Values it = m_transactions.begin().values(), end = m_transactions.end().values(); it != end; ++it)
 352         (*it)->abort(IGNORE_EXCEPTION);
 353     this->close();
 354     enqueueEvent(Event::create(EventTypeNames::close));
 355 }
 356
 357 void IDBDatabase::close()
 358 {
 359     IDB_TRACE("IDBDatabase::close");
 360     if (m_closePending)
 361         return;
 362
 363     m_closePending = true;
 364
 365     if (m_transactions.isEmpty())
 366         closeConnection();
 367 }
 368
 369 void IDBDatabase::closeConnection()
 370 {
 371     ASSERT(m_closePending);
 372     ASSERT(m_transactions.isEmpty());
 373
 374     if (m_backend) {
 375         m_backend->close();
 376         m_backend.clear();
 377     }
 378
 379     if (m_contextStopped || !executionContext())
 380         return;
 381
 382     EventQueue* eventQueue = executionContext()->eventQueue();
 383     // Remove any pending versionchange events scheduled to fire on this
 384     // connection. They would have been scheduled by the backend when another
 385     // connection called setVersion, but the frontend connection is being
 386     // closed before they could fire.
 387     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
 388         bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
 389         ASSERT_UNUSED(removed, removed);
 390     }
 391 }
 392
 393 void IDBDatabase::onVersionChange(int64_t oldVersion, int64_t newVersion)
 394 {
 395     IDB_TRACE("IDBDatabase::onVersionChange");
 396     if (m_contextStopped || !executionContext())
 397         return;
 398
 399     if (m_closePending) {
 400         // If we're pending, that means there's a busy transaction. We won't
 401         // fire 'versionchange' but since we're not closing immediately the
 402         // back-end should still send out 'blocked'.
 403         m_backend->versionChangeIgnored();
 404         return;
 405     }
 406
 407     Nullable<unsigned long long> newVersionNullable = (newVersion == IDBDatabaseMetadata::NoIntVersion) ? Nullable<unsigned long long>() : Nullable<unsigned long long>(newVersion);
 408     enqueueEvent(IDBVersionChangeEvent::create(EventTypeNames::versionchange, oldVersion, newVersionNullable));
 409 }
 410
 411 void IDBDatabase::enqueueEvent(PassRefPtrWillBeRawPtr<Event> event)
 412 {
 413     ASSERT(!m_contextStopped);
 414     ASSERT(executionContext());
 415     EventQueue* eventQueue = executionContext()->eventQueue();
 416     event->setTarget(this);
 417     eventQueue->enqueueEvent(event.get());
 418     m_enqueuedEvents.append(event);
 419 }
 420
 421 bool IDBDatabase::dispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 422 {
 423     IDB_TRACE("IDBDatabase::dispatchEvent");
 424     if (m_contextStopped || !executionContext())
 425         return false;
 426     ASSERT(event->type() == EventTypeNames::versionchange || event->type() == EventTypeNames::close);
 427     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
 428         if (m_enqueuedEvents[i].get() == event.get())
 429             m_enqueuedEvents.remove(i);
 430     }
 431
 432     bool result = EventTarget::dispatchEvent(event.get());
 433     if (event->type() == EventTypeNames::versionchange && !m_closePending && m_backend)
 434         m_backend->versionChangeIgnored();
 435     return result;
 436 }
 437
 438 int64_t IDBDatabase::findObjectStoreId(const String& name) const
 439 {
 440     for (IDBDatabaseMetadata::ObjectStoreMap::const_iterator it = m_metadata.objectStores.begin(); it != m_metadata.objectStores.end(); ++it) {
 441         if (it->value.name == name) {
 442             ASSERT(it->key != IDBObjectStoreMetadata::InvalidId);
 443             return it->key;
 444         }
 445     }
 446     return IDBObjectStoreMetadata::InvalidId;
 447 }
 448
 449 bool IDBDatabase::hasPendingActivity() const
 450 {
 451     // The script wrapper must not be collected before the object is closed or
 452     // we can't fire a "versionchange" event to let script manually close the connection.
 453     return !m_closePending && hasEventListeners() && !m_contextStopped;
 454 }
 455
 456 void IDBDatabase::stop()
 457 {
 458     m_contextStopped = true;
 459
 460     // Immediately close the connection to the back end. Don't attempt a
 461     // normal close() since that may wait on transactions which require a
 462     // round trip to the back-end to abort.
 463     if (m_backend) {
 464         m_backend->close();
 465         m_backend.clear();
 466     }
 467 }
 468
 469 const AtomicString& IDBDatabase::interfaceName() const
 470 {
 471     return EventTargetNames::IDBDatabase;
 472 }
 473
 474 ExecutionContext* IDBDatabase::executionContext() const
 475 {
 476     return ActiveDOMObject::executionContext();
 477 }
 478
 479 } // namespace blink