IndexedDB: Remove IndexedDBCallbacksWrapper

content/browser/indexed_db/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/indexed_db/indexed_db_dispatcher_host.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 143 matching lines @@
   return transaction_id | (static_cast<uint64>(pid) << 32);
 }
 
 int64 IndexedDBDispatcherHost::RendererTransactionId(
     int64 host_transaction_id) {
   DCHECK(host_transaction_id >> 32 == base::GetProcId(peer_handle()))
       << "Invalid renderer target for transaction id";
   return host_transaction_id & 0xffffffff;
 }
 
-IndexedDBCursor* IndexedDBDispatcherHost::GetCursorFromId(
-    int32 ipc_cursor_id) {
+IndexedDBCursor* IndexedDBDispatcherHost::GetCursorFromId(int32 ipc_cursor_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   return cursor_dispatcher_host_->map_.Lookup(ipc_cursor_id);
 }
 
 ::IndexedDBDatabaseMetadata IndexedDBDispatcherHost::ConvertMetadata(
     const content::IndexedDBDatabaseMetadata& web_metadata) {
   ::IndexedDBDatabaseMetadata metadata;
   metadata.id = web_metadata.id;
   metadata.name = web_metadata.name;
   metadata.version = web_metadata.version;
@@ skipping 32 matching lines @@
   }
   return metadata;
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryGetDatabaseNames(
     const IndexedDBHostMsg_FactoryGetDatabaseNames_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   Context()->GetIDBFactory()->GetDatabaseNames(
-      IndexedDBCallbacksWrapper::Create(
-          new IndexedDBCallbacks<std::vector<string16> >(
-              this, params.ipc_thread_id, params.ipc_callbacks_id)),
+      IndexedDBCallbacks::Create(
+          this, params.ipc_thread_id, params.ipc_callbacks_id),
       base::UTF8ToUTF16(params.database_identifier),
       indexed_db_path);
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryOpen(
     const IndexedDBHostMsg_FactoryOpen_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   GURL origin_url =
       webkit_database::GetOriginFromIdentifier(params.database_identifier);
 
   int64 host_transaction_id = HostTransactionId(params.transaction_id);
 
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
-  scoped_refptr<IndexedDBCallbacksWrapper> callbacks_proxy =
-      IndexedDBCallbacksWrapper::Create(
-          new IndexedDBCallbacksDatabase(this,
-                                         params.ipc_thread_id,
-                                         params.ipc_callbacks_id,
-                                         params.ipc_database_callbacks_id,
-                                         host_transaction_id,
-                                         origin_url));
-  scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks_proxy =
+  scoped_refptr<IndexedDBCallbacks> callbacks =
+      IndexedDBCallbacks::Create(this,
+                                 params.ipc_thread_id,
+                                 params.ipc_callbacks_id,
+                                 params.ipc_database_callbacks_id,
+                                 host_transaction_id,
+                                 origin_url);
+  scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks =
       IndexedDBDatabaseCallbacks::Create(
           this, params.ipc_thread_id, params.ipc_database_callbacks_id);
-  callbacks_proxy->SetDatabaseCallbacks(database_callbacks_proxy);
+  callbacks->SetDatabaseCallbacks(database_callbacks);
   Context()->GetIDBFactory()->
       Open(params.name,
            params.version,
            host_transaction_id,
-           callbacks_proxy,
-           database_callbacks_proxy,
+           callbacks,
+           database_callbacks,
            base::UTF8ToUTF16(params.database_identifier),
            indexed_db_path);
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryDeleteDatabase(
     const IndexedDBHostMsg_FactoryDeleteDatabase_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
   Context()->GetIDBFactory()->DeleteDatabase(
       params.name,
-      IndexedDBCallbacksWrapper::Create(
-          new IndexedDBCallbacks<std::vector<char> >(
-              this, params.ipc_thread_id, params.ipc_callbacks_id)),
+      IndexedDBCallbacks::Create(
+          this, params.ipc_thread_id, params.ipc_callbacks_id),
       base::UTF8ToUTF16(params.database_identifier),
       indexed_db_path);
 }
 
 void IndexedDBDispatcherHost::FinishTransaction(int64 host_transaction_id,
                                                 bool committed) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   TransactionIDToURLMap& transaction_url_map =
       database_dispatcher_host_->transaction_url_map_;
   TransactionIDToSizeMap& transaction_size_map =
@@ skipping 44 matching lines @@
   if (!return_object) {
     NOTREACHED() << "Uh oh, couldn't find object with id "
                  << ipc_return_object_id;
     RecordAction(UserMetricsAction("BadMessageTerminate_IDBMF"));
     BadMessageReceived();
   }
   return return_object;
 }
 
 template <typename MapType>
-void IndexedDBDispatcherHost::DestroyObject(
-    MapType* map,
-    int32 ipc_object_id) {
+void IndexedDBDispatcherHost::DestroyObject(MapType* map, int32 ipc_object_id) {
   GetOrTerminateProcess(map, ipc_object_id);
   map->Remove(ipc_object_id);
 }
 
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::DatabaseDispatcherHost
 //
 
 IndexedDBDispatcherHost::DatabaseDispatcherHost::DatabaseDispatcherHost(
     IndexedDBDispatcherHost* parent)
@@ skipping 121 matching lines @@
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
 
   database->createTransaction(
-      host_transaction_id,
-      params.object_store_ids,
-      params.mode);
+      host_transaction_id, params.object_store_ids, params.mode);
   transaction_database_map_[host_transaction_id] = params.ipc_database_id;
   parent_->RegisterTransactionId(host_transaction_id,
                                  database_url_map_[params.ipc_database_id]);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClose(
     int32 ipc_database_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
@@ skipping 16 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGet(
     const IndexedDBHostMsg_DatabaseGet_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<IndexedDBCallbacksBase> callbacks(
-      new IndexedDBCallbacks<std::vector<char> >(
-          parent_, params.ipc_thread_id, params.ipc_callbacks_id));
+  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+      parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   database->get(parent_->HostTransactionId(params.transaction_id),
                 params.object_store_id,
                 params.index_id,
                 params.key_range,
                 params.key_only,
-                callbacks.release());
+                callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
     const IndexedDBHostMsg_DatabasePut_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
-  scoped_ptr<IndexedDBCallbacksBase> callbacks(
-      new IndexedDBCallbacks<IndexedDBKey>(
-          parent_, params.ipc_thread_id, params.ipc_callbacks_id));
+  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+      parent_, params.ipc_thread_id, params.ipc_callbacks_id));
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   // TODO(alecflett): Avoid a copy here.
   std::vector<char> value_copy = params.value;
   database->put(host_transaction_id,
                 params.object_store_id,
                 &value_copy,
                 params.key,
                 params.put_mode,
-                callbacks.release(),
+                callbacks,
                 params.index_ids,
                 params.index_keys);
   TransactionIDToSizeMap* map =
       &parent_->database_dispatcher_host_->transaction_size_map_;
   // Size can't be big enough to overflow because it represents the
   // actual bytes passed through IPC.
   (*map)[host_transaction_id] += params.value.size();
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexKeys(
@@ skipping 40 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnOpenCursor(
     const IndexedDBHostMsg_DatabaseOpenCursor_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<IndexedDBCallbacksBase> callbacks(
-      new IndexedDBCallbacks<IndexedDBCursor>(
-          parent_, params.ipc_thread_id, params.ipc_callbacks_id, -1));
+  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+      parent_, params.ipc_thread_id, params.ipc_callbacks_id, -1));
   database->openCursor(parent_->HostTransactionId(params.transaction_id),
                        params.object_store_id,
                        params.index_id,
                        params.key_range,
                        params.direction,
                        params.key_only,
                        params.task_type,
-                       callbacks.release());
+                       callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCount(
     const IndexedDBHostMsg_DatabaseCount_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<IndexedDBCallbacksBase> callbacks(
-      new IndexedDBCallbacks<std::vector<char> >(
-          parent_, params.ipc_thread_id, params.ipc_callbacks_id));
+  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+      parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   database->count(parent_->HostTransactionId(params.transaction_id),
                   params.object_store_id,
                   params.index_id,
                   params.key_range,
-                  callbacks.release());
+                  callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteRange(
     const IndexedDBHostMsg_DatabaseDeleteRange_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<IndexedDBCallbacksBase> callbacks(
-      new IndexedDBCallbacks<std::vector<char> >(
-          parent_, params.ipc_thread_id, params.ipc_callbacks_id));
+  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+      parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   database->deleteRange(parent_->HostTransactionId(params.transaction_id),
                         params.object_store_id,
                         params.key_range,
-                        callbacks.release());
+                        callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClear(
     int32 ipc_thread_id,
     int32 ipc_callbacks_id,
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<IndexedDBCallbacksBase> callbacks(
-      new IndexedDBCallbacks<std::vector<char> >(
-          parent_, ipc_thread_id, ipc_callbacks_id));
+  scoped_refptr<IndexedDBCallbacks> callbacks(
+      IndexedDBCallbacks::Create(parent_, ipc_thread_id, ipc_callbacks_id));
 
-  database->clear(parent_->HostTransactionId(transaction_id),
-                  object_store_id,
-                  callbacks.release());
+  database->clear(
+      parent_->HostTransactionId(transaction_id), object_store_id, callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnAbort(
     int32 ipc_database_id,
     int64 transaction_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
@@ skipping 110 matching lines @@
     unsigned long count) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->Advance(
       count,
-      IndexedDBCallbacksWrapper::Create(new IndexedDBCallbacks<IndexedDBCursor>(
-          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id)));
+      IndexedDBCallbacks::Create(
+          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnContinue(
     int32 ipc_cursor_id,
     int32 ipc_thread_id,
     int32 ipc_callbacks_id,
     const IndexedDBKey& key) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->ContinueFunction(
       make_scoped_ptr(new IndexedDBKey(key)),
-      IndexedDBCallbacksWrapper::Create(new IndexedDBCallbacks<IndexedDBCursor>(
-          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id)));
+      IndexedDBCallbacks::Create(
+          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnPrefetch(
     int32 ipc_cursor_id,
     int32 ipc_thread_id,
     int32 ipc_callbacks_id,
     int n) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->PrefetchContinue(
       n,
-      IndexedDBCallbacksWrapper::Create(new IndexedDBCallbacks<IndexedDBCursor>(
-          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id)));
+      IndexedDBCallbacks::Create(
+          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnPrefetchReset(
     int32 ipc_cursor_id,
     int used_prefetches,
     int unused_prefetches) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->PrefetchReset(used_prefetches, unused_prefetches);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32 ipc_object_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content