Support renaming of IndexedDB indexes and object stores.

content/browser/indexed_db/indexed_db_database.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/indexed_db/indexed_db_database.h"
 
 #include <math.h>
 
 #include <limits>
 #include <set>
@@ skipping 385 matching lines @@
   }
   metadata_.object_stores[object_store.id] = object_store;
 }
 
 void IndexedDBDatabase::RemoveObjectStore(int64_t object_store_id) {
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   metadata_.object_stores.erase(object_store_id);
 }
 
+void IndexedDBDatabase::SetObjectStoreName(
+    int64_t object_store_id, const base::string16& name) {
+  DCHECK(metadata_.object_stores.find(object_store_id) !=
+         metadata_.object_stores.end());
+  metadata_.object_stores[object_store_id].name = name;
+}
+
 void IndexedDBDatabase::AddIndex(int64_t object_store_id,
                                  const IndexedDBIndexMetadata& index,
                                  int64_t new_max_index_id) {
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   IndexedDBObjectStoreMetadata object_store =
       metadata_.object_stores[object_store_id];
 
   DCHECK(object_store.indexes.find(index.id) == object_store.indexes.end());
   object_store.indexes[index.id] = index;
   if (new_max_index_id != IndexedDBIndexMetadata::kInvalidId) {
     DCHECK_LT(object_store.max_index_id, new_max_index_id);
     object_store.max_index_id = new_max_index_id;
   }
   metadata_.object_stores[object_store_id] = object_store;
 }
 
 void IndexedDBDatabase::RemoveIndex(int64_t object_store_id, int64_t index_id) {
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   IndexedDBObjectStoreMetadata object_store =
       metadata_.object_stores[object_store_id];
 
   DCHECK(object_store.indexes.find(index_id) != object_store.indexes.end());
   object_store.indexes.erase(index_id);
   metadata_.object_stores[object_store_id] = object_store;
 }
 
+void IndexedDBDatabase::SetIndexName(
+    int64_t object_store_id, int64_t index_id, const base::string16& name) {
+  DCHECK(metadata_.object_stores.find(object_store_id) !=
+         metadata_.object_stores.end());
+  IndexedDBObjectStoreMetadata object_store =
+      metadata_.object_stores[object_store_id];
+
+  DCHECK(object_store.indexes.find(index_id) != object_store.indexes.end());
+  object_store.indexes[index_id].name = name;
+  metadata_.object_stores[object_store_id] = object_store;
+}
+
 leveldb::Status IndexedDBDatabase::OpenInternal() {
   bool success = false;
   leveldb::Status s = backing_store_->GetIDBDatabaseMetaData(
       metadata_.name, &metadata_, &success);
   DCHECK(success == (metadata_.id != kInvalidId)) << "success = " << success
                                                   << " id = " << metadata_.id;
   if (!s.ok())
     return s;
   if (success)
     return backing_store_->GetObjectStores(metadata_.id,
@@ skipping 148 matching lines @@
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreOperation,
                  this,
                  object_store_id));
 }
 
+void IndexedDBDatabase::RenameObjectStore(int64_t transaction_id,
+                                          int64_t object_store_id,
+                                          const base::string16& new_name) {
+  IDB_TRACE1("IndexedDBDatabase::RenameObjectStore", "txn.id", transaction_id);
+  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
+  if (!transaction)
+    return;
+  DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
+
+  if (!ValidateObjectStoreId(object_store_id))
+    return;
+
+  // Store renaming is done synchronously, as it may be followed by
+  // index creation (also sync) since preemptive OpenCursor/SetIndexKeys
+  // may follow.
+  const IndexedDBObjectStoreMetadata object_store_metadata =
+      metadata_.object_stores[object_store_id];
+
+  leveldb::Status s =
+      backing_store_->RenameObjectStore(transaction->BackingStoreTransaction(),
+                                        transaction->database()->id(),
+                                        object_store_metadata.id, new_name);
+  if (!s.ok()) {
+    IndexedDBDatabaseError error(
+        blink::WebIDBDatabaseExceptionUnknownError,
+        ASCIIToUTF16("Internal error renaming object store '") +
+            object_store_metadata.name + ASCIIToUTF16("' to '") + new_name +
+            ASCIIToUTF16("'."));
+    transaction->Abort(error);
+    if (s.IsCorruption())
+      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
+    return;
+  }
+
+  transaction->ScheduleAbortTask(
+      base::Bind(&IndexedDBDatabase::RenameObjectStoreAbortOperation,
+                 this,
+                 object_store_id,
+                 object_store_metadata.name));
+  SetObjectStoreName(object_store_id, new_name);
+}
+
 void IndexedDBDatabase::CreateIndex(int64_t transaction_id,
                                     int64_t object_store_id,
                                     int64_t index_id,
                                     const base::string16& name,
                                     const IndexedDBKeyPath& key_path,
                                     bool unique,
                                     bool multi_entry) {
   IDB_TRACE1("IndexedDBDatabase::CreateIndex", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
@@ skipping 103 matching lines @@
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
     int64_t object_store_id,
     const IndexedDBIndexMetadata& index_metadata,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::DeleteIndexAbortOperation");
   AddIndex(object_store_id, index_metadata, IndexedDBIndexMetadata::kInvalidId);
 }
 
+void IndexedDBDatabase::RenameIndex(int64_t transaction_id,
+                                    int64_t object_store_id,
+                                    int64_t index_id,
+                                    const base::string16& new_name) {
+  IDB_TRACE1("IndexedDBDatabase::RenameIndex", "txn.id", transaction_id);
+  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
+  if (!transaction)
+    return;
+  DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
+
+  if (!ValidateObjectStoreIdAndIndexId(object_store_id, index_id))
+    return;
+
+  // Index renaming is done synchronously since preemptive
+  // OpenCursor/SetIndexKeys may follow.
+
+  const IndexedDBIndexMetadata index_metadata =
+      metadata_.object_stores[object_store_id].indexes[index_id];
+
+  leveldb::Status s =
+      backing_store_->RenameIndex(transaction->BackingStoreTransaction(),
+                                  transaction->database()->id(),
+                                  object_store_id,
+                                  index_id,
+                                  new_name);
+  if (!s.ok()) {
+    base::string16 error_string =
+        ASCIIToUTF16("Internal error renaming index '") +
+        index_metadata.name + ASCIIToUTF16("' to '") + new_name +
+        ASCIIToUTF16("'.");
+    transaction->Abort(IndexedDBDatabaseError(
+        blink::WebIDBDatabaseExceptionUnknownError, error_string));
+    return;
+  }
+
+  transaction->ScheduleAbortTask(
+      base::Bind(&IndexedDBDatabase::RenameIndexAbortOperation,
+                 this,
+                 object_store_id,
+                 index_id,
+                 index_metadata.name));
+  SetIndexName(object_store_id, index_id, new_name);
+}
+
+void IndexedDBDatabase::RenameIndexAbortOperation(
+    int64_t object_store_id,
+    int64_t index_id,
+    const base::string16& old_name,
+    IndexedDBTransaction* transaction) {
+  DCHECK(!transaction);
+  IDB_TRACE("IndexedDBDatabase::RenameIndexAbortOperation");
+  SetIndexName(object_store_id, index_id, old_name);
+}
+
 void IndexedDBDatabase::Commit(int64_t transaction_id) {
   // The frontend suggests that we commit, but we may have previously initiated
   // an abort, and so have disposed of the transaction. on_abort has already
   // been dispatched to the frontend, so it will find out about that
   // asynchronously.
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction) {
     scoped_refptr<IndexedDBFactory> factory = factory_;
     leveldb::Status s = transaction->Commit();
     if (s.IsCorruption()) {
@@ skipping 1260 matching lines @@
 
 void IndexedDBDatabase::DeleteObjectStoreAbortOperation(
     const IndexedDBObjectStoreMetadata& object_store_metadata,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::DeleteObjectStoreAbortOperation");
   AddObjectStore(object_store_metadata,
                  IndexedDBObjectStoreMetadata::kInvalidId);
 }
 
+void IndexedDBDatabase::RenameObjectStoreAbortOperation(
+    int64_t object_store_id,
+    const base::string16& old_name,
+    IndexedDBTransaction* transaction) {
+  DCHECK(!transaction);
+  IDB_TRACE("IndexedDBDatabase::RenameObjectStoreAbortOperation");
+  SetObjectStoreName(object_store_id, old_name);
+}
+
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content