Align IndexedDB metadata rollback on transaction abort to spec.

third_party/WebKit/Source/modules/indexeddb/IDBTransaction.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 100 matching lines @@
     ASSERT(m_requestList.isEmpty() || m_contextStopped);
 }
 
 DEFINE_TRACE(IDBTransaction)
 {
     visitor->trace(m_database);
     visitor->trace(m_openDBRequest);
     visitor->trace(m_error);
     visitor->trace(m_requestList);
     visitor->trace(m_objectStoreMap);
-    visitor->trace(m_createdObjectStores);
     visitor->trace(m_deletedObjectStores);
-    visitor->trace(m_objectStoreCleanupMap);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 void IDBTransaction::setError(DOMException* error)
 {
     ASSERT(m_state != Finished);
     ASSERT(error);
 
     // The first error to be set is the true cause of the
@@ skipping 22 matching lines @@
     int64_t objectStoreId = m_database->findObjectStoreId(name);
     if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
         ASSERT(isVersionChange());
         exceptionState.throwDOMException(NotFoundError, IDBDatabase::noSuchObjectStoreErrorMessage);
         return nullptr;
     }
 
     const IDBDatabaseMetadata& metadata = m_database->metadata();
 
     IDBObjectStore* objectStore = IDBObjectStore::create(metadata.objectStores.get(objectStoreId), this);
+    DCHECK(!m_objectStoreMap.contains(name));
     m_objectStoreMap.set(name, objectStore);
-    m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
     return objectStore;
 }
 
 void IDBTransaction::objectStoreCreated(const String& name, IDBObjectStore* objectStore)
 {
-    ASSERT(m_state != Finished);
-    ASSERT(isVersionChange());
+    DCHECK(m_state != Finished);
+    DCHECK(isVersionChange());
+    DCHECK(!m_objectStoreMap.contains(name));
     m_objectStoreMap.set(name, objectStore);
-    m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
-    m_createdObjectStores.add(objectStore);
 }
 
 void IDBTransaction::objectStoreDeleted(const String& name)
 {
     ASSERT(m_state != Finished);
     ASSERT(isVersionChange());
     IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
     if (it != m_objectStoreMap.end()) {
         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)
 {
     DCHECK_NE(m_state, Finished) << "A finished transaction tried to setActive(" << (active ? "true" : "false") << ")";
     if (m_state == Finishing)
         return;
     ASSERT(active != (m_state == Active));
@@ skipping 12 matching lines @@
 
     m_state = Finishing;
 
     if (m_contextStopped)
         return;
 
     for (IDBRequest* request : m_requestList)
         request->abort();
     m_requestList.clear();
 
-    for (IDBObjectStore* store : m_createdObjectStores) {
-        store->abort();
-        store->markDeleted();
+    if (isVersionChange()) {
+        // Marking created object stores as deleted.
+        for (auto storeMapIterator : m_objectStoreMap) {
+            IDBObjectStore* store = storeMapIterator.value;
+            auto it = m_previousMetadata.objectStores.find(store->id());
+            if (it == m_previousMetadata.objectStores.end()) {
+                store->versionChangeTransactionAborted();
+                store->markDeleted();
+            }
+        }
     }
 
     if (backendDB())
         backendDB()->abort(m_id);
 }
 
 void IDBTransaction::registerRequest(IDBRequest* request)
 {
     ASSERT(request);
     ASSERT(m_state == Active);
@@ skipping 19 matching lines @@
     if (m_state != Finishing) {
         // Abort was not triggered by front-end.
         ASSERT(error);
         setError(error);
 
         // Outstanding requests must be aborted.
         for (IDBRequest* request : m_requestList)
             request->abort();
         m_requestList.clear();
 
-        // Newly created stores must be marked as deleted.
-        for (IDBObjectStore* store : m_createdObjectStores)
-            store->markDeleted();
+        if (isVersionChange()) {
+            for (IDBObjectStore* store : m_deletedObjectStores) {
+                if (!m_previousMetadata.objectStores.contains(store->id()))
+                    store->markDeleted();
+                store->versionChangeTransactionAborted();
+            }
 
-        // Used stores may need to mark indexes as deleted.
-        for (auto& it : m_objectStoreCleanupMap)
-            it.key->abort();
+            for (const auto& storeMapIterator : m_objectStoreMap) {
+                IDBObjectStore* store = storeMapIterator.value;
+
+                // Newly created stores must be marked as deleted.
+                if (!m_previousMetadata.objectStores.contains(store->id()))
+                    store->markDeleted();
+
+                // Modified stores may need to mark indexes as deleted.
+                store->versionChangeTransactionAborted();
+            }
+        }
 
         m_state = Finishing;
     }
 
     if (isVersionChange()) {
-        for (auto& it : m_objectStoreCleanupMap)
-            it.key->setMetadata(it.value);
+        for (IDBObjectStore* store : m_deletedObjectStores) {
+            const auto& it = m_previousMetadata.objectStores.find(store->id());
+            if (it != m_previousMetadata.objectStores.end())
+                store->rollbackMetadata(it->value);
+        }
+        for (const auto& storeMapIterator : m_objectStoreMap) {
+            IDBObjectStore* store = storeMapIterator.value;
+            const auto& it = m_previousMetadata.objectStores.find(store->id());
+            if (it != m_previousMetadata.objectStores.end())
+                store->rollbackMetadata(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));
 
     m_database->transactionFinished(this);
 }
 
 void IDBTransaction::onComplete()
 {
     IDB_TRACE("IDBTransaction::onComplete");
     if (m_contextStopped) {
         m_database->transactionFinished(this);
         return;
     }
 
     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));
 
     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
@@ skipping 66 matching lines @@
     ASSERT(event->target() == this);
     m_state = Finished;
 
     // Break reference cycles.
     // TODO(jsbell): This can be removed c/o Oilpan.
     for (auto& it : m_objectStoreMap)
         it.value->transactionFinished();
     m_objectStoreMap.clear();
     for (auto& it : m_deletedObjectStores)
         it->transactionFinished();
-    m_createdObjectStores.clear();
     m_deletedObjectStores.clear();
 
     HeapVector<Member<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);
     DispatchEventResult dispatchResult = IDBEventDispatcher::dispatch(event, targets);
     // FIXME: Try to construct a test where |this| outlives openDBRequest and we
@@ skipping 26 matching lines @@
     event->setTarget(this);
     eventQueue->enqueueEvent(event);
 }
 
 WebIDBDatabase* IDBTransaction::backendDB() const
 {
     return m_database->backend();
 }
 
 } // namespace blink