IPC implementation for create/delete ObjectStore/Index

content/browser/in_process_webkit/indexed_db_dispatcher_host.cc

 // Copyright (c) 2012 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/in_process_webkit/indexed_db_dispatcher_host.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 335 matching lines @@
     }
   }
 }
 
 bool IndexedDBDispatcherHost::DatabaseDispatcherHost::OnMessageReceived(
     const IPC::Message& message, bool* msg_is_ok) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(IndexedDBDispatcherHost::DatabaseDispatcherHost,
                            message, *msg_is_ok)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseMetadata, OnMetadata)
+    IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCreateObjectStoreOld,
+                        OnCreateObjectStoreOld)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCreateObjectStore,
                         OnCreateObjectStore)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDeleteObjectStore,
                         OnDeleteObjectStore)
+    IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDeleteObjectStoreOld,
+                        OnDeleteObjectStoreOld)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCreateTransaction,
                         OnCreateTransaction)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseClose, OnClose)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDestroyed, OnDestroyed)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseGet, OnGet)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabasePut, OnPut)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseSetIndexKeys,
                         OnSetIndexKeys)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseSetIndexesReady,
                         OnSetIndexesReady)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseOpenCursor, OnOpenCursor)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCount, OnCount)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDeleteRange, OnDeleteRange)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseClear, OnClear)
+    IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCreateIndex,
+                        OnCreateIndex)
+    IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDeleteIndex,
+                        OnDeleteIndex)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::Send(
     IPC::Message* message) {
   parent_->Send(message);
 }
 
@@ skipping 29 matching lines @@
       idb_index_metadata.name = web_index_metadata.name;
       idb_index_metadata.keyPath = IndexedDBKeyPath(web_index_metadata.keyPath);
       idb_index_metadata.unique = web_index_metadata.unique;
       idb_index_metadata.multiEntry = web_index_metadata.multiEntry;
       idb_store_metadata.indexes.push_back(idb_index_metadata);
     }
     metadata->object_stores.push_back(idb_store_metadata);
   }
 }
 
-void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateObjectStore(
-    const IndexedDBHostMsg_DatabaseCreateObjectStore_Params& params,
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateObjectStoreOld(
+    const IndexedDBHostMsg_DatabaseCreateObjectStoreOld_Params& params,
     int32* object_store_id, WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, params.ipc_database_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.ipc_transaction_id);
   if (!idb_database || !idb_transaction)
     return;
 
   *ec = 0;
   WebIDBObjectStore* object_store = idb_database->createObjectStore(
       params.id, params.name, params.key_path, params.auto_increment,
       *idb_transaction, *ec);
   *object_store_id = *ec ? 0 : parent_->Add(object_store);
   if (parent_->Context()->IsOverQuota(
       database_url_map_[params.ipc_database_id])) {
     idb_transaction->abort();
   }
 }
 
-void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateObjectStore(
+    const IndexedDBHostMsg_DatabaseCreateObjectStore_Params& params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  WebIDBDatabase* database = parent_->GetOrTerminateProcess(
+      &map_, params.ipc_database_id);
+  if (!database)
+    return;
+
+  database->createObjectStore(
+      parent_->HostTransactionId(params.transaction_id),
+      params.object_store_id,
+      params.name, params.key_path, params.auto_increment);
+  if (parent_->Context()->IsOverQuota(
+      database_url_map_[params.ipc_database_id])) {
+    database->abort(params.transaction_id);
+  }
+}
+
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStoreOld(
     int32 ipc_database_id,
-    int64 index_id,
+    int64 object_store_id,
     int32 ipc_transaction_id,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, ipc_database_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, ipc_transaction_id);
   if (!idb_database || !idb_transaction)
     return;
 
   *ec = 0;
-  idb_database->deleteObjectStore(index_id, *idb_transaction, *ec);
+  idb_database->deleteObjectStore(object_store_id, *idb_transaction, *ec);
+}
+
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
+    int32 ipc_database_id,
+    int64 transaction_id,
+    int64 object_store_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  WebIDBDatabase* database = parent_->GetOrTerminateProcess(
+      &map_, ipc_database_id);
+  if (!database)
+    return;
+
+  database->deleteObjectStore(parent_->HostTransactionId(transaction_id),
+                              object_store_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateTransaction(
     int32 ipc_thread_id,
     int32 ipc_database_id,
     int64 transaction_id,
     const std::vector<int64>& object_store_ids,
     int32 mode,
     int32* ipc_transaction_id) {
   WebIDBDatabase* database = parent_->GetOrTerminateProcess(
@@ skipping 173 matching lines @@
 
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(
           parent_, ipc_thread_id,
           ipc_response_id));
 
   database->clear(parent_->HostTransactionId(transaction_id),
                   object_store_id, callbacks.release());
 }
 
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateIndex(
+    const IndexedDBHostMsg_DatabaseCreateIndex_Params& params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  WebIDBDatabase* database = parent_->GetOrTerminateProcess(
+      &map_, params.ipc_database_id);
+  if (!database)
+    return;
+
+  database->createIndex(
+      parent_->HostTransactionId(params.transaction_id),
+      params.object_store_id,
+      params.index_id,
+      params.name,
+      params.key_path,
+      params.unique,
+      params.multi_entry);
+  if (parent_->Context()->IsOverQuota(
+      database_url_map_[params.ipc_database_id])) {
+    database->abort(params.transaction_id);
+  }
+}
+
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteIndex(
+    int32 ipc_database_id,
+    int64 transaction_id,
+    int64 object_store_id,
+    int64 index_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  WebIDBDatabase* database = parent_->GetOrTerminateProcess(
+      &map_, ipc_database_id);
+  if (!database)
+    return;
+
+  database->deleteIndex(parent_->HostTransactionId(transaction_id),
+                        object_store_id, index_id);
+}
+
+
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::IndexDispatcherHost
 //
 
 IndexedDBDispatcherHost::IndexDispatcherHost::IndexDispatcherHost(
     IndexedDBDispatcherHost* parent)
     : parent_(parent) {
   map_.set_check_on_null_data(true);
 }
 
@@ skipping 623 matching lines @@
 void IndexedDBDispatcherHost::TransactionDispatcherHost::OnDestroyed(
     int32 ipc_object_id) {
   // TODO(dgrogan): This doesn't seem to be happening with some version change
   // transactions. Possibly introduced with integer version support.
   transaction_ipc_size_map_.erase(ipc_object_id);
   transaction_url_map_.erase(ipc_object_id);
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content