IndexedDB: Eliminate WebIDBCursor wrapper

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"
 #include "base/files/file_path.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
+#include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
-#include "content/browser/indexed_db/webidbcursor_impl.h"
-#include "content/browser/indexed_db/webidbcursor_impl.h"
 #include "content/browser/indexed_db/webidbdatabase_impl.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabase.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
@@ skipping 77 matching lines @@
                           OnIDBFactoryGetDatabaseNames)
       IPC_MESSAGE_HANDLER(IndexedDBHostMsg_FactoryOpen, OnIDBFactoryOpen)
       IPC_MESSAGE_HANDLER(IndexedDBHostMsg_FactoryDeleteDatabase,
                           OnIDBFactoryDeleteDatabase)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   }
   return handled;
 }
 
-int32 IndexedDBDispatcherHost::Add(WebIDBCursorImpl* idb_cursor) {
+int32 IndexedDBDispatcherHost::Add(IndexedDBCursor* idb_cursor) {
   if (!cursor_dispatcher_host_) {
-    delete idb_cursor;
     return 0;
   }
   return cursor_dispatcher_host_->map_.Add(idb_cursor);
 }
 
 int32 IndexedDBDispatcherHost::Add(WebIDBDatabaseImpl* idb_database,
                                    int32 ipc_thread_id,
                                    const GURL& origin_url) {
   if (!database_dispatcher_host_) {
     delete idb_database;
@@ skipping 25 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;
 }
 
-WebIDBCursorImpl* IndexedDBDispatcherHost::GetCursorFromId(
+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;
@@ skipping 132 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 ObjectType>
+ObjectType* IndexedDBDispatcherHost::GetOrTerminateProcess(
+    RefIDMap<ObjectType>* map,
+    int32 ipc_return_object_id) {
+  DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
+  ObjectType* return_object = map->Lookup(ipc_return_object_id);
+  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(
-    IDMap<ObjectType, IDMapOwnPointer>* map,
+    MapType* map,
     int32 ipc_object_id) {
   GetOrTerminateProcess(map, ipc_object_id);
   map->Remove(ipc_object_id);
 }
 
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::DatabaseDispatcherHost
 //
 
 IndexedDBDispatcherHost::DatabaseDispatcherHost::DatabaseDispatcherHost(
@@ skipping 257 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<WebIDBCursorImpl>(
+      new IndexedDBCallbacks<IndexedDBCursor>(
           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());
 }
@@ skipping 171 matching lines @@
   parent_->Send(message);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnAdvance(
     int32 ipc_cursor_id,
     int32 ipc_thread_id,
     int32 ipc_callbacks_id,
     unsigned long count) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
-  WebIDBCursorImpl* idb_cursor =
+  IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
-  idb_cursor->advance(
+  idb_cursor->Advance(
       count,
-      new IndexedDBCallbacks<WebIDBCursorImpl>(
-          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
+      IndexedDBCallbacksWrapper::Create(new IndexedDBCallbacks<IndexedDBCursor>(
+          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());
-  WebIDBCursorImpl* idb_cursor =
+  IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
-  idb_cursor->continueFunction(
-      key,
-      new IndexedDBCallbacks<WebIDBCursorImpl>(
-          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
+  idb_cursor->ContinueFunction(
+      make_scoped_ptr(new IndexedDBKey(key)),
+      IndexedDBCallbacksWrapper::Create(new IndexedDBCallbacks<IndexedDBCursor>(
+          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());
-  WebIDBCursorImpl* idb_cursor =
+  IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
-  idb_cursor->prefetchContinue(
+  idb_cursor->PrefetchContinue(
       n,
-      new IndexedDBCallbacks<WebIDBCursorImpl>(
-          parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
+      IndexedDBCallbacksWrapper::Create(new IndexedDBCallbacks<IndexedDBCursor>(
+          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());
-  WebIDBCursorImpl* idb_cursor =
+  IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
-  idb_cursor->prefetchReset(used_prefetches, unused_prefetches);
+  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