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 108 matching lines @@
   ActiveDOMObject::trace(visitor);
 }
 
 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) {
-  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);
+void IDBDatabase::setMetadata(const IDBDatabaseMetadata& metadata) {
+  m_metadata = metadata;
 }
 
-void IDBDatabase::indexDeleted(int64_t objectStoreId, int64_t indexId) {
-  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_NE(indexIterator, storeMetadata.indexes.end());
-  indexIterator->value.name = newName;
+void IDBDatabase::setDatabaseMetadata(const IDBDatabaseMetadata& metadata) {
+  m_metadata.copyDatabaseMetadataFrom(metadata);
 }
 
 void IDBDatabase::transactionCreated(IDBTransaction* transaction) {
   DCHECK(transaction);
   DCHECK(!m_transactions.contains(transaction->id()));
   m_transactions.add(transaction->id(), transaction);
 
   if (transaction->isVersionChange()) {
     DCHECK(!m_versionChangeTransaction);
     m_versionChangeTransaction = transaction;
@@ skipping 22 matching lines @@
 
 void IDBDatabase::onComplete(int64_t transactionId) {
   DCHECK(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->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->name;
 }
 
 IDBObjectStore* IDBDatabase::createObjectStore(const String& name,
                                                const IDBKeyPath& keyPath,
                                                bool autoIncrement,
                                                ExceptionState& exceptionState) {
   IDB_TRACE("IDBDatabase::createObjectStore");
   recordApiCallsHistogram(IDBCreateObjectStoreCall);
 
   if (!m_versionChangeTransaction) {
@@ skipping 35 matching lines @@
     return nullptr;
   }
 
   if (!m_backend) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   int64_t objectStoreId = m_metadata.maxObjectStoreId + 1;
+  DCHECK_NE(objectStoreId, IDBObjectStoreMetadata::InvalidId);
   m_backend->createObjectStore(m_versionChangeTransaction->id(), objectStoreId,
                                name, keyPath, autoIncrement);
 
-  IDBObjectStoreMetadata metadata(name, objectStoreId, keyPath, autoIncrement,
-                                  WebIDBDatabase::minimumIndexId);
+  RefPtr<IDBObjectStoreMetadata> storeMetadata = adoptRef(
+      new IDBObjectStoreMetadata(name, objectStoreId, keyPath, autoIncrement,
+                                 WebIDBDatabase::minimumIndexId));
   IDBObjectStore* objectStore =
-      IDBObjectStore::create(metadata, m_versionChangeTransaction.get());
-  m_metadata.objectStores.set(metadata.id, metadata);
+      IDBObjectStore::create(storeMetadata, m_versionChangeTransaction.get());
+  m_versionChangeTransaction->objectStoreCreated(name, objectStore);
+  m_metadata.objectStores.set(objectStoreId, std::move(storeMetadata));
   ++m_metadata.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,
@@ skipping 19 matching lines @@
     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);
@@ skipping 148 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->name == name) {
       DCHECK_NE(it.key, IDBObjectStoreMetadata::InvalidId);
       return it.key;
     }
   }
   return IDBObjectStoreMetadata::InvalidId;
 }
 
-void IDBDatabase::objectStoreRenamed(int64_t objectStoreId,
-                                     const String& newName) {
+void IDBDatabase::renameObjectStore(int64_t objectStoreId,
+                                    const String& 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));
-  IDBDatabaseMetadata::ObjectStoreMap::iterator it =
-      m_metadata.objectStores.find(objectStoreId);
-  it->value.name = newName;
+
+  m_backend->renameObjectStore(m_versionChangeTransaction->id(), objectStoreId,
+                               newName);
+
+  IDBObjectStoreMetadata* objectStoreMetadata =
+      m_metadata.objectStores.get(objectStoreId);
+  m_versionChangeTransaction->objectStoreRenamed(objectStoreMetadata->name,
+                                                 newName);
+  objectStoreMetadata->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->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::contextDestroyed() {
@@ skipping 18 matching lines @@
 
 void IDBDatabase::recordApiCallsHistogram(IndexedDatabaseMethods method) {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       EnumerationHistogram, apiCallsHistogram,
       new EnumerationHistogram("WebCore.IndexedDB.FrontEndAPICalls",
                                IDBMethodsMax));
   apiCallsHistogram.count(method);
 }
 
 }  // namespace blink