| /* |
| * Copyright (C) 2010 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "modules/indexeddb/IDBTransaction.h" |
| |
| #include "bindings/v8/ExceptionState.h" |
| #include "bindings/v8/ExceptionStatePlaceholder.h" |
| #include "core/dom/DOMError.h" |
| #include "core/dom/ExecutionContext.h" |
| #include "core/events/EventQueue.h" |
| #include "core/inspector/ScriptCallStack.h" |
| #include "modules/indexeddb/IDBDatabase.h" |
| #include "modules/indexeddb/IDBEventDispatcher.h" |
| #include "modules/indexeddb/IDBIndex.h" |
| #include "modules/indexeddb/IDBObjectStore.h" |
| #include "modules/indexeddb/IDBOpenDBRequest.h" |
| #include "modules/indexeddb/IDBPendingTransactionMonitor.h" |
| #include "modules/indexeddb/IDBTracing.h" |
| |
| namespace WebCore { |
| |
| PassRefPtr<IDBTransaction> IDBTransaction::create(ExecutionContext* context, int64_t id, const Vector<String>& objectStoreNames, IndexedDB::TransactionMode mode, IDBDatabase* db) |
| { |
| IDBOpenDBRequest* openDBRequest = 0; |
| RefPtr<IDBTransaction> transaction(adoptRef(new IDBTransaction(context, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata()))); |
| transaction->suspendIfNeeded(); |
| return transaction.release(); |
| } |
| |
| PassRefPtr<IDBTransaction> IDBTransaction::create(ExecutionContext* context, int64_t id, IDBDatabase* db, IDBOpenDBRequest* openDBRequest, const IDBDatabaseMetadata& previousMetadata) |
| { |
| RefPtr<IDBTransaction> transaction(adoptRef(new IDBTransaction(context, id, Vector<String>(), IndexedDB::TransactionVersionChange, db, openDBRequest, previousMetadata))); |
| transaction->suspendIfNeeded(); |
| return transaction.release(); |
| } |
| |
| const AtomicString& IDBTransaction::modeReadOnly() |
| { |
| DEFINE_STATIC_LOCAL(AtomicString, readonly, ("readonly", AtomicString::ConstructFromLiteral)); |
| return readonly; |
| } |
| |
| const AtomicString& IDBTransaction::modeReadWrite() |
| { |
| DEFINE_STATIC_LOCAL(AtomicString, readwrite, ("readwrite", AtomicString::ConstructFromLiteral)); |
| return readwrite; |
| } |
| |
| const AtomicString& IDBTransaction::modeVersionChange() |
| { |
| DEFINE_STATIC_LOCAL(AtomicString, versionchange, ("versionchange", AtomicString::ConstructFromLiteral)); |
| return versionchange; |
| } |
| |
| const AtomicString& IDBTransaction::modeReadOnlyLegacy() |
| { |
| DEFINE_STATIC_LOCAL(AtomicString, readonly, ("0", AtomicString::ConstructFromLiteral)); |
| return readonly; |
| } |
| |
| const AtomicString& IDBTransaction::modeReadWriteLegacy() |
| { |
| DEFINE_STATIC_LOCAL(AtomicString, readwrite, ("1", AtomicString::ConstructFromLiteral)); |
| return readwrite; |
| } |
| |
| |
| IDBTransaction::IDBTransaction(ExecutionContext* context, int64_t id, const Vector<String>& objectStoreNames, IndexedDB::TransactionMode mode, IDBDatabase* db, IDBOpenDBRequest* openDBRequest, const IDBDatabaseMetadata& previousMetadata) |
| : ActiveDOMObject(context) |
| , m_id(id) |
| , m_database(db) |
| , m_objectStoreNames(objectStoreNames) |
| , m_openDBRequest(openDBRequest) |
| , m_mode(mode) |
| , m_state(Active) |
| , m_hasPendingActivity(true) |
| , m_contextStopped(false) |
| , m_previousMetadata(previousMetadata) |
| { |
| ScriptWrappable::init(this); |
| if (mode == IndexedDB::TransactionVersionChange) { |
| // Not active until the callback. |
| m_state = Inactive; |
| } |
| |
| // We pass a reference of this object before it can be adopted. |
| relaxAdoptionRequirement(); |
| if (m_state == Active) |
| IDBPendingTransactionMonitor::addNewTransaction(this); |
| m_database->transactionCreated(this); |
| } |
| |
| IDBTransaction::~IDBTransaction() |
| { |
| ASSERT(m_state == Finished || m_contextStopped); |
| ASSERT(m_requestList.isEmpty() || m_contextStopped); |
| } |
| |
| const String& IDBTransaction::mode() const |
| { |
| return modeToString(m_mode); |
| } |
| |
| void IDBTransaction::setError(PassRefPtr<DOMError> error) |
| { |
| ASSERT(m_state != Finished); |
| ASSERT(error); |
| |
| // The first error to be set is the true cause of the |
| // transaction abort. |
| if (!m_error) { |
| m_error = error; |
| } |
| } |
| |
| PassRefPtr<IDBObjectStore> IDBTransaction::objectStore(const String& name, ExceptionState& es) |
| { |
| if (m_state == Finished) { |
| es.throwDOMException(InvalidStateError, IDBDatabase::transactionFinishedErrorMessage); |
| return 0; |
| } |
| |
| IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name); |
| if (it != m_objectStoreMap.end()) |
| return it->value; |
| |
| if (!isVersionChange() && !m_objectStoreNames.contains(name)) { |
| es.throwDOMException(NotFoundError, IDBDatabase::noSuchObjectStoreErrorMessage); |
| return 0; |
| } |
| |
| int64_t objectStoreId = m_database->findObjectStoreId(name); |
| if (objectStoreId == IDBObjectStoreMetadata::InvalidId) { |
| ASSERT(isVersionChange()); |
| es.throwDOMException(NotFoundError, IDBDatabase::noSuchObjectStoreErrorMessage); |
| return 0; |
| } |
| |
| const IDBDatabaseMetadata& metadata = m_database->metadata(); |
| |
| RefPtr<IDBObjectStore> objectStore = IDBObjectStore::create(metadata.objectStores.get(objectStoreId), this); |
| objectStoreCreated(name, objectStore); |
| return objectStore.release(); |
| } |
| |
| void IDBTransaction::objectStoreCreated(const String& name, PassRefPtr<IDBObjectStore> prpObjectStore) |
| { |
| ASSERT(m_state != Finished); |
| RefPtr<IDBObjectStore> objectStore = prpObjectStore; |
| m_objectStoreMap.set(name, objectStore); |
| if (isVersionChange()) |
| m_objectStoreCleanupMap.set(objectStore, objectStore->metadata()); |
| } |
| |
| void IDBTransaction::objectStoreDeleted(const String& name) |
| { |
| ASSERT(m_state != Finished); |
| ASSERT(isVersionChange()); |
| IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name); |
| if (it != m_objectStoreMap.end()) { |
| RefPtr<IDBObjectStore> objectStore = it->value; |
| m_objectStoreMap.remove(name); |
| objectStore->markDeleted(); |
| m_objectStoreCleanupMap.set(objectStore, objectStore->metadata()); |
| m_deletedObjectStores.add(objectStore); |
| } |
| } |
| |
| void IDBTransaction::setActive(bool active) |
| { |
| ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to setActive(%s)", active ? "true" : "false"); |
| if (m_state == Finishing) |
| return; |
| ASSERT(active != (m_state == Active)); |
| m_state = active ? Active : Inactive; |
| |
| if (!active && m_requestList.isEmpty()) |
| backendDB()->commit(m_id); |
| } |
| |
| void IDBTransaction::abort(ExceptionState& es) |
| { |
| if (m_state == Finishing || m_state == Finished) { |
| es.throwDOMException(InvalidStateError, IDBDatabase::transactionFinishedErrorMessage); |
| return; |
| } |
| |
| m_state = Finishing; |
| |
| if (!m_contextStopped) { |
| while (!m_requestList.isEmpty()) { |
| RefPtr<IDBRequest> request = *m_requestList.begin(); |
| m_requestList.remove(request); |
| request->abort(); |
| } |
| } |
| |
| RefPtr<IDBTransaction> selfRef = this; |
| backendDB()->abort(m_id); |
| } |
| |
| void IDBTransaction::registerRequest(IDBRequest* request) |
| { |
| ASSERT(request); |
| ASSERT(m_state == Active); |
| m_requestList.add(request); |
| } |
| |
| void IDBTransaction::unregisterRequest(IDBRequest* request) |
| { |
| ASSERT(request); |
| // If we aborted the request, it will already have been removed. |
| m_requestList.remove(request); |
| } |
| |
| void IDBTransaction::onAbort(PassRefPtr<DOMError> prpError) |
| { |
| IDB_TRACE("IDBTransaction::onAbort"); |
| RefPtr<DOMError> error = prpError; |
| ASSERT(m_state != Finished); |
| |
| if (m_state != Finishing) { |
| ASSERT(error.get()); |
| setError(error.release()); |
| |
| // Abort was not triggered by front-end, so outstanding requests must |
| // be aborted now. |
| while (!m_requestList.isEmpty()) { |
| RefPtr<IDBRequest> request = *m_requestList.begin(); |
| m_requestList.remove(request); |
| request->abort(); |
| } |
| m_state = Finishing; |
| } |
| |
| if (isVersionChange()) { |
| for (IDBObjectStoreMetadataMap::iterator it = m_objectStoreCleanupMap.begin(); it != m_objectStoreCleanupMap.end(); ++it) |
| it->key->setMetadata(it->value); |
| m_database->setMetadata(m_previousMetadata); |
| m_database->close(); |
| } |
| m_objectStoreCleanupMap.clear(); |
| |
| // Enqueue events before notifying database, as database may close which enqueues more events and order matters. |
| enqueueEvent(Event::createBubble(EventTypeNames::abort)); |
| |
| // If script has stopped and GC has completed, database may have last reference to this object. |
| RefPtr<IDBTransaction> protect(this); |
| m_database->transactionFinished(this); |
| } |
| |
| void IDBTransaction::onComplete() |
| { |
| IDB_TRACE("IDBTransaction::onComplete"); |
| ASSERT(m_state != Finished); |
| m_state = Finishing; |
| m_objectStoreCleanupMap.clear(); |
| |
| // Enqueue events before notifying database, as database may close which enqueues more events and order matters. |
| enqueueEvent(Event::create(EventTypeNames::complete)); |
| |
| // If script has stopped and GC has completed, database may have last reference to this object. |
| RefPtr<IDBTransaction> protect(this); |
| m_database->transactionFinished(this); |
| } |
| |
| bool IDBTransaction::hasPendingActivity() const |
| { |
| // FIXME: In an ideal world, we should return true as long as anyone has a or can |
| // get a handle to us or any child request object and any of those have |
| // event listeners. This is in order to handle user generated events properly. |
| return m_hasPendingActivity && !m_contextStopped; |
| } |
| |
| IndexedDB::TransactionMode IDBTransaction::stringToMode(const String& modeString, ExceptionState& es) |
| { |
| if (modeString.isNull() |
| || modeString == IDBTransaction::modeReadOnly()) |
| return IndexedDB::TransactionReadOnly; |
| if (modeString == IDBTransaction::modeReadWrite()) |
| return IndexedDB::TransactionReadWrite; |
| |
| es.throwTypeError(); |
| return IndexedDB::TransactionReadOnly; |
| } |
| |
| const AtomicString& IDBTransaction::modeToString(IndexedDB::TransactionMode mode) |
| { |
| switch (mode) { |
| case IndexedDB::TransactionReadOnly: |
| return IDBTransaction::modeReadOnly(); |
| break; |
| |
| case IndexedDB::TransactionReadWrite: |
| return IDBTransaction::modeReadWrite(); |
| break; |
| |
| case IndexedDB::TransactionVersionChange: |
| return IDBTransaction::modeVersionChange(); |
| break; |
| } |
| |
| ASSERT_NOT_REACHED(); |
| return IDBTransaction::modeReadOnly(); |
| } |
| |
| const AtomicString& IDBTransaction::interfaceName() const |
| { |
| return EventTargetNames::IDBTransaction; |
| } |
| |
| ExecutionContext* IDBTransaction::executionContext() const |
| { |
| return ActiveDOMObject::executionContext(); |
| } |
| |
| bool IDBTransaction::dispatchEvent(PassRefPtr<Event> event) |
| { |
| IDB_TRACE("IDBTransaction::dispatchEvent"); |
| ASSERT(m_state != Finished); |
| ASSERT(m_hasPendingActivity); |
| ASSERT(executionContext()); |
| ASSERT(event->target() == this); |
| m_state = Finished; |
| |
| // Break reference cycles. |
| for (IDBObjectStoreMap::iterator it = m_objectStoreMap.begin(); it != m_objectStoreMap.end(); ++it) |
| it->value->transactionFinished(); |
| m_objectStoreMap.clear(); |
| for (IDBObjectStoreSet::iterator it = m_deletedObjectStores.begin(); it != m_deletedObjectStores.end(); ++it) |
| (*it)->transactionFinished(); |
| m_deletedObjectStores.clear(); |
| |
| Vector<RefPtr<EventTarget> > targets; |
| targets.append(this); |
| targets.append(db()); |
| |
| // FIXME: When we allow custom event dispatching, this will probably need to change. |
| ASSERT(event->type() == EventTypeNames::complete || event->type() == EventTypeNames::abort); |
| bool returnValue = IDBEventDispatcher::dispatch(event.get(), targets); |
| // FIXME: Try to construct a test where |this| outlives openDBRequest and we |
| // get a crash. |
| if (m_openDBRequest) { |
| ASSERT(isVersionChange()); |
| m_openDBRequest->transactionDidFinishAndDispatch(); |
| } |
| m_hasPendingActivity = false; |
| return returnValue; |
| } |
| |
| void IDBTransaction::stop() |
| { |
| if (m_contextStopped) |
| return; |
| |
| m_contextStopped = true; |
| |
| abort(IGNORE_EXCEPTION); |
| } |
| |
| void IDBTransaction::enqueueEvent(PassRefPtr<Event> event) |
| { |
| ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to enqueue an event of type %s.", event->type().string().utf8().data()); |
| if (m_contextStopped || !executionContext()) |
| return; |
| |
| EventQueue* eventQueue = executionContext()->eventQueue(); |
| event->setTarget(this); |
| eventQueue->enqueueEvent(event); |
| } |
| |
| IDBDatabaseBackendInterface* IDBTransaction::backendDB() const |
| { |
| return db()->backend(); |
| } |
| |
| } // namespace WebCore |