IndexedDB: Coding conventions and cleanup

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/process.h"
@@ skipping 193 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(
-      IndexedDBCallbacks::Create(
+      new IndexedDBCallbacks(
           this, params.ipc_thread_id, params.ipc_callbacks_id),
       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<IndexedDBCallbacks> callbacks =
-      IndexedDBCallbacks::Create(this,
-                                 params.ipc_thread_id,
-                                 params.ipc_callbacks_id,
-                                 params.ipc_database_callbacks_id,
-                                 host_transaction_id,
-                                 origin_url);
+      new IndexedDBCallbacks(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(
+      new IndexedDBDatabaseCallbacks(
           this, params.ipc_thread_id, params.ipc_database_callbacks_id);
-  Context()->GetIDBFactory()->
-      Open(params.name,
-           params.version,
-           host_transaction_id,
-           callbacks,
-           database_callbacks,
-           params.database_identifier,
-           indexed_db_path);
+  Context()->GetIDBFactory()->Open(params.name,
+                                   params.version,
+                                   host_transaction_id,
+                                   callbacks,
+                                   database_callbacks,
+                                   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,
-      IndexedDBCallbacks::Create(
+      new IndexedDBCallbacks(
           this, params.ipc_thread_id, params.ipc_callbacks_id),
       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_;
@@ skipping 186 matching lines @@
     const IndexedDBHostMsg_DatabaseCreateTransaction_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
 
-  connection->database()->CreateTransaction(host_transaction_id,
-                                            connection,
-                                            params.object_store_ids,
-                                            params.mode);
+  connection->database()->CreateTransaction(
+      host_transaction_id, connection, 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());
   IndexedDBConnection* connection =
@@ skipping 16 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGet(
     const IndexedDBHostMsg_DatabaseGet_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection)
     return;
 
-  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+  scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->Get(
       parent_->HostTransactionId(params.transaction_id),
       params.object_store_id,
       params.index_id,
       make_scoped_ptr(new IndexedDBKeyRange(params.key_range)),
       params.key_only,
       callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
     const IndexedDBHostMsg_DatabasePut_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection)
     return;
-  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+  scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       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::string value_copy(params.value);
   connection->database()->Put(
       host_transaction_id,
       params.object_store_id,
       &value_copy,
       make_scoped_ptr(new IndexedDBKey(params.key)),
@@ skipping 53 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnOpenCursor(
     const IndexedDBHostMsg_DatabaseOpenCursor_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection)
     return;
 
-  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+  scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id, -1));
   connection->database()->OpenCursor(
       parent_->HostTransactionId(params.transaction_id),
       params.object_store_id,
       params.index_id,
       make_scoped_ptr(new IndexedDBKeyRange(params.key_range)),
       static_cast<indexed_db::CursorDirection>(params.direction),
       params.key_only,
       static_cast<IndexedDBDatabase::TaskType>(params.task_type),
       callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCount(
     const IndexedDBHostMsg_DatabaseCount_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection)
     return;
 
-  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+  scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->Count(
       parent_->HostTransactionId(params.transaction_id),
       params.object_store_id,
       params.index_id,
       make_scoped_ptr(new IndexedDBKeyRange(params.key_range)),
       callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteRange(
     const IndexedDBHostMsg_DatabaseDeleteRange_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection)
     return;
 
-  scoped_refptr<IndexedDBCallbacks> callbacks(IndexedDBCallbacks::Create(
+  scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->DeleteRange(
       parent_->HostTransactionId(params.transaction_id),
       params.object_store_id,
       make_scoped_ptr(new IndexedDBKeyRange(params.key_range)),
       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());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection)
     return;
 
   scoped_refptr<IndexedDBCallbacks> callbacks(
-      IndexedDBCallbacks::Create(parent_, ipc_thread_id, ipc_callbacks_id));
+      new IndexedDBCallbacks(parent_, ipc_thread_id, ipc_callbacks_id));
 
   connection->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());
@@ skipping 113 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,
-      IndexedDBCallbacks::Create(
+      new IndexedDBCallbacks(
           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->Continue(
       make_scoped_ptr(new IndexedDBKey(key)),
-      IndexedDBCallbacks::Create(
+      new IndexedDBCallbacks(
           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,
-      IndexedDBCallbacks::Create(
+      new IndexedDBCallbacks(
           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