Align IndexedDB metadata rollback on transaction abort to spec.

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

 /*
  * 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
@@ skipping 91 matching lines @@
 }
 
 int64_t IDBDatabase::nextTransactionId()
 {
     // Only keep a 32-bit counter to allow ports to use the other 32
     // bits of the id.
     static int currentTransactionId = 0;
     return atomicIncrement(&currentTransactionId);
 }
 
-void IDBDatabase::indexCreated(int64_t objectStoreId, const IDBIndexMetadata& metadata)
+void IDBDatabase::setMetadata(const IDBDatabaseMetadata& metadata)
 {
-    IDBDatabaseMetadata::ObjectStoreMap::iterator it = m_metadata.objectStores.find(objectStoreId);
-    ASSERT_WITH_SECURITY_IMPLICATION(it != m_metadata.objectStores.end());
-    it->value.indexes.set(metadata.id, metadata);
+    m_metadata = metadata;
 }
 
-void IDBDatabase::indexDeleted(int64_t objectStoreId, int64_t indexId)
+void IDBDatabase::setOwnMetadata(const IDBDatabaseOwnMetadata& metadata)
 {
-    IDBDatabaseMetadata::ObjectStoreMap::iterator it = m_metadata.objectStores.find(objectStoreId);
-    ASSERT_WITH_SECURITY_IMPLICATION(it != m_metadata.objectStores.end());
-    it->value.indexes.remove(indexId);
-}
-
-void IDBDatabase::indexRenamed(int64_t objectStoreId, int64_t indexId, const String& newName)
-{
-    IDBDatabaseMetadata::ObjectStoreMap::iterator storeIterator = m_metadata.objectStores.find(objectStoreId);
-    SECURITY_DCHECK(storeIterator != m_metadata.objectStores.end());
-
-    IDBObjectStoreMetadata& storeMetadata = storeIterator->value;
-    IDBObjectStoreMetadata::IndexMap::iterator indexIterator = storeMetadata.indexes.find(indexId);
-    DCHECK(indexIterator != storeMetadata.indexes.end());
-    indexIterator->value.name = newName;
+    m_metadata.own = metadata;
 }
 
 void IDBDatabase::transactionCreated(IDBTransaction* transaction)
 {
     ASSERT(transaction);
     ASSERT(!m_transactions.contains(transaction->id()));
     m_transactions.add(transaction->id(), transaction);
 
     if (transaction->isVersionChange()) {
         ASSERT(!m_versionChangeTransaction);
@@ skipping 26 matching lines @@
 void IDBDatabase::onComplete(int64_t transactionId)
 {
     ASSERT(m_transactions.contains(transactionId));
     m_transactions.get(transactionId)->onComplete();
 }
 
 DOMStringList* IDBDatabase::objectStoreNames() const
 {
     DOMStringList* objectStoreNames = DOMStringList::create(DOMStringList::IndexedDB);
     for (const auto& it : m_metadata.objectStores)
-        objectStoreNames->append(it.value.name);
+        objectStoreNames->append(it.value->own.name);
     objectStoreNames->sort();
     return objectStoreNames;
 }
 
 const String& IDBDatabase::getObjectStoreName(int64_t objectStoreId) const
 {
     const auto& it = m_metadata.objectStores.find(objectStoreId);
     DCHECK(it != m_metadata.objectStores.end());
-    return it->value.name;
+    return it->value->own.name;
 }
 
 IDBObjectStore* IDBDatabase::createObjectStore(const String& name, const IDBKeyPath& keyPath, bool autoIncrement, ExceptionState& exceptionState)
 {
     IDB_TRACE("IDBDatabase::createObjectStore");
     recordApiCallsHistogram(IDBCreateObjectStoreCall);
 
     if (!m_versionChangeTransaction) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
         return nullptr;
@@ skipping 20 matching lines @@
     if (autoIncrement && ((keyPath.getType() == IDBKeyPath::StringType && keyPath.string().isEmpty()) || keyPath.getType() == IDBKeyPath::ArrayType)) {
         exceptionState.throwDOMException(InvalidAccessError, "The autoIncrement option was set but the keyPath option was empty or an array.");
         return nullptr;
     }
 
     if (!m_backend) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return nullptr;
     }
 
-    int64_t objectStoreId = m_metadata.maxObjectStoreId + 1;
+    int64_t objectStoreId = m_metadata.own.maxObjectStoreId + 1;
+    DCHECK(objectStoreId != IDBObjectStoreMetadata::InvalidId);
     m_backend->createObjectStore(m_versionChangeTransaction->id(), objectStoreId, name, keyPath, autoIncrement);
 
-    IDBObjectStoreMetadata metadata(name, objectStoreId, keyPath, autoIncrement, WebIDBDatabase::minimumIndexId);
-    IDBObjectStore* objectStore = IDBObjectStore::create(metadata, m_versionChangeTransaction.get());
-    m_metadata.objectStores.set(metadata.id, metadata);
-    ++m_metadata.maxObjectStoreId;
+    RefPtr<IDBObjectStoreMetadata> storeMetadata = adoptRef(new IDBObjectStoreMetadata(
+        name, objectStoreId, keyPath, autoIncrement, WebIDBDatabase::minimumIndexId));
+    IDBObjectStore* objectStore = IDBObjectStore::create(storeMetadata, m_versionChangeTransaction.get());
+    m_versionChangeTransaction->objectStoreCreated(name, objectStore);
+    m_metadata.objectStores.set(objectStoreId, std::move(storeMetadata));
+    ++m_metadata.own.maxObjectStoreId;
 
-    m_versionChangeTransaction->objectStoreCreated(name, objectStore);
     return objectStore;
 }
 
 void IDBDatabase::deleteObjectStore(const String& name, ExceptionState& exceptionState)
 {
     IDB_TRACE("IDBDatabase::deleteObjectStore");
     recordApiCallsHistogram(IDBDeleteObjectStoreCall);
     if (!m_versionChangeTransaction) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
         return;
@@ skipping 12 matching lines @@
         exceptionState.throwDOMException(NotFoundError, "The specified object store was not found.");
         return;
     }
 
     if (!m_backend) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return;
     }
 
     m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);
-    m_versionChangeTransaction->objectStoreDeleted(name);
+    m_versionChangeTransaction->objectStoreDeleted(objectStoreId, name);
     m_metadata.objectStores.remove(objectStoreId);
 }
 
 IDBTransaction* IDBDatabase::transaction(ScriptState* scriptState, const StringOrStringSequenceOrDOMStringList& storeNames, const String& modeString, ExceptionState& exceptionState)
 {
     IDB_TRACE("IDBDatabase::transaction");
     recordApiCallsHistogram(IDBTransactionCall);
 
     HashSet<String> scope;
     if (storeNames.isString()) {
@@ skipping 17 matching lines @@
     if (m_closePending) {
         exceptionState.throwDOMException(InvalidStateError, "The database connection is closing.");
         return nullptr;
     }
 
     if (!m_backend) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return nullptr;
     }
 
-
     if (scope.isEmpty()) {
         exceptionState.throwDOMException(InvalidAccessError, "The storeNames parameter was empty.");
         return nullptr;
     }
 
     Vector<int64_t> objectStoreIds;
     for (const String& name : scope) {
         int64_t objectStoreId = findObjectStoreId(name);
         if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
             exceptionState.throwDOMException(NotFoundError, "One of the specified object stores was not found.");
             return nullptr;
         }
         objectStoreIds.append(objectStoreId);
     }
 
     WebIDBTransactionMode mode = IDBTransaction::stringToMode(modeString);
     if (mode != WebIDBTransactionModeReadOnly && mode != WebIDBTransactionModeReadWrite) {
         exceptionState.throwTypeError("The mode provided ('" + modeString + "') is not one of 'readonly' or 'readwrite'.");
         return nullptr;
     }
 
     int64_t transactionId = nextTransactionId();
     m_backend->createTransaction(transactionId, WebIDBDatabaseCallbacksImpl::create(m_databaseCallbacks).release(), objectStoreIds, mode);
 
-    return IDBTransaction::create(scriptState, transactionId, scope, mode, this);
+    return IDBTransaction::createNonVersionChange(scriptState, transactionId, scope, mode, this);
 }
 
 void IDBDatabase::forceClose()
 {
     for (const auto& it : m_transactions)
         it.value->abort(IGNORE_EXCEPTION);
     this->close();
     enqueueEvent(Event::create(EventTypeNames::close));
 }
 
@@ skipping 74 matching lines @@
 
     DispatchEventResult dispatchResult = EventTarget::dispatchEventInternal(event);
     if (event->type() == EventTypeNames::versionchange && !m_closePending && m_backend)
         m_backend->versionChangeIgnored();
     return dispatchResult;
 }
 
 int64_t IDBDatabase::findObjectStoreId(const String& name) const
 {
     for (const auto& it : m_metadata.objectStores) {
-        if (it.value.name == name) {
+        if (it.value->own.name == name) {
             ASSERT(it.key != IDBObjectStoreMetadata::InvalidId);
             return it.key;
         }
     }
     return IDBObjectStoreMetadata::InvalidId;
 }
 
-void IDBDatabase::objectStoreRenamed(int64_t storeId, const String& newName)
+void IDBDatabase::renameObjectStore(int64_t objectStoreId, const String& newName)
 {
-    DCHECK(m_metadata.objectStores.contains(storeId));
-    IDBDatabaseMetadata::ObjectStoreMap::iterator it = m_metadata.objectStores.find(storeId);
-    it->value.name = newName;
+    DCHECK(m_versionChangeTransaction) << "Object store renamed on database without a versionchange transaction";
+    DCHECK(m_versionChangeTransaction->isActive()) << "Object store renamed when versionchange transaction is not active";
+    DCHECK(m_backend) << "Object store renamed after database connection closed";
+    DCHECK(m_metadata.objectStores.contains(objectStoreId));
+
+    m_backend->renameObjectStore(m_versionChangeTransaction->id(), objectStoreId, newName);
+
+    IDBDatabaseMetadata::ObjectStoreMap::iterator it = m_metadata.objectStores.find(objectStoreId);
+    IDBObjectStoreMetadata* objectStoreMetadata = it->value.get();
+    m_versionChangeTransaction->objectStoreRenamed(objectStoreMetadata->own.name, newName);
+    objectStoreMetadata->own.name = newName;
+}
+
+void IDBDatabase::revertObjectStoreCreation(int64_t objectStoreId)
+{
+    DCHECK(m_versionChangeTransaction) << "Object store metadata reverted on database without a versionchange transaction";
+    DCHECK(!m_versionChangeTransaction->isActive()) << "Object store metadata reverted when versionchange transaction is still active";
+    DCHECK(m_metadata.objectStores.contains(objectStoreId));
+    m_metadata.objectStores.remove(objectStoreId);
+}
+
+void IDBDatabase::revertObjectStoreMetadata(RefPtr<IDBObjectStoreMetadata> oldMetadata)
+{
+    DCHECK(m_versionChangeTransaction) << "Object store metadata reverted on database without a versionchange transaction";
+    DCHECK(!m_versionChangeTransaction->isActive()) << "Object store metadata reverted when versionchange transaction is still active";
+    DCHECK(oldMetadata.get());
+    m_metadata.objectStores.set(oldMetadata->own.id, std::move(oldMetadata));
 }
 
 bool IDBDatabase::hasPendingActivity() const
 {
     // The script wrapper must not be collected before the object is closed or
     // we can't fire a "versionchange" event to let script manually close the connection.
     return !m_closePending && hasEventListeners() && !m_contextStopped;
 }
 
 void IDBDatabase::stop()
@@ skipping 19 matching lines @@
     return ActiveDOMObject::getExecutionContext();
 }
 
 void IDBDatabase::recordApiCallsHistogram(IndexedDatabaseMethods method)
 {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, apiCallsHistogram, new EnumerationHistogram("WebCore.IndexedDB.FrontEndAPICalls", IDBMethodsMax));
     apiCallsHistogram.count(method);
 }
 
 } // namespace blink