Remove content/browser dependency on WebKit::WebIDBCallbacks and WebKit::WebIDBDatabaseCallbacks

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"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/in_process_webkit/indexed_db_callbacks.h"
 #include "content/browser/in_process_webkit/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.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/WebData.h"
-#include "third_party/WebKit/public/platform/WebIDBCursor.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabase.h"
-#include "third_party/WebKit/public/platform/WebIDBDatabaseCallbacks.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
-#include "third_party/WebKit/public/platform/WebIDBFactory.h"
 #include "third_party/WebKit/public/platform/WebIDBMetadata.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "webkit/base/file_path_string_conversions.h"
 #include "webkit/base/origin_url_conversions.h"
 #include "webkit/browser/database/database_util.h"
 
 using webkit_database::DatabaseUtil;
 using WebKit::WebData;
-using WebKit::WebIDBCallbacks;
-using WebKit::WebIDBCursor;
-using WebKit::WebIDBDatabase;
 using WebKit::WebIDBDatabaseError;
 using WebKit::WebIDBKey;
 using WebKit::WebIDBMetadata;
 using WebKit::WebString;
 using WebKit::WebVector;
 
 namespace content {
 namespace {
 
 template <class T>
@@ skipping 69 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(WebIDBCursor* idb_cursor) {
+int32 IndexedDBDispatcherHost::Add(WebIDBCursorImpl* idb_cursor) {
   if (!cursor_dispatcher_host_) {
     delete idb_cursor;
     return 0;
   }
   return cursor_dispatcher_host_->map_.Add(idb_cursor);
 }
 
-int32 IndexedDBDispatcherHost::Add(WebIDBDatabase* idb_database,
+int32 IndexedDBDispatcherHost::Add(WebIDBDatabaseImpl* idb_database,
                                    int32 ipc_thread_id,
                                    const GURL& origin_url) {
   if (!database_dispatcher_host_) {
     delete idb_database;
     return 0;
   }
   int32 ipc_database_id = database_dispatcher_host_->map_.Add(idb_database);
   Context()->ConnectionOpened(origin_url, idb_database);
   database_dispatcher_host_->database_url_map_[ipc_database_id] = origin_url;
   return ipc_database_id;
@@ skipping 19 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;
 }
 
-WebIDBCursor* IndexedDBDispatcherHost::GetCursorFromId(int32 ipc_cursor_id) {
+WebIDBCursorImpl* IndexedDBDispatcherHost::GetCursorFromId(
+    int32 ipc_cursor_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   return cursor_dispatcher_host_->map_.Lookup(ipc_cursor_id);
 }
 
-IndexedDBDatabaseMetadata IndexedDBDispatcherHost::ConvertMetadata(
+::IndexedDBDatabaseMetadata IndexedDBDispatcherHost::ConvertMetadata(
     const WebIDBMetadata& web_metadata) {
-  IndexedDBDatabaseMetadata metadata;
+  ::IndexedDBDatabaseMetadata metadata;
   metadata.id = web_metadata.id;
   metadata.name = web_metadata.name;
   metadata.version = web_metadata.version;
   metadata.int_version = web_metadata.intVersion;
   metadata.max_object_store_id = web_metadata.maxObjectStoreId;
 
   for (size_t i = 0; i < web_metadata.objectStores.size(); ++i) {
     const WebIDBMetadata::ObjectStore& web_store_metadata =
         web_metadata.objectStores[i];
-    IndexedDBObjectStoreMetadata idb_store_metadata;
+    ::IndexedDBObjectStoreMetadata idb_store_metadata;
     idb_store_metadata.id = web_store_metadata.id;
     idb_store_metadata.name = web_store_metadata.name;
     idb_store_metadata.keyPath = IndexedDBKeyPath(web_store_metadata.keyPath);
     idb_store_metadata.autoIncrement = web_store_metadata.autoIncrement;
     idb_store_metadata.max_index_id = web_store_metadata.maxIndexId;
 
     for (size_t j = 0; j < web_store_metadata.indexes.size(); ++j) {
       const WebIDBMetadata::Index& web_index_metadata =
           web_store_metadata.indexes[j];
-      IndexedDBIndexMetadata idb_index_metadata;
+      ::IndexedDBIndexMetadata idb_index_metadata;
       idb_index_metadata.id = web_index_metadata.id;
       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);
   }
   return metadata;
@@ skipping 124 matching lines @@
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::CloseAll() {
   // Abort outstanding transactions started by connections in the associated
   // front-end to unblock later transactions. This should only occur on unclean
   // (crash) or abrupt (process-kill) shutdowns.
   for (TransactionIDToDatabaseIDMap::iterator iter =
            transaction_database_map_.begin();
        iter != transaction_database_map_.end();) {
     int64 transaction_id = iter->first;
     int32 ipc_database_id = iter->second;
     ++iter;
-    WebIDBDatabase* database = map_.Lookup(ipc_database_id);
+    WebIDBDatabaseImpl* database = map_.Lookup(ipc_database_id);
     if (database) {
       database->abort(
           transaction_id,
           WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError));
     }
   }
   DCHECK(transaction_database_map_.empty());
 
   for (WebIDBObjectIDToURLMap::iterator iter = database_url_map_.begin();
        iter != database_url_map_.end();
        iter++) {
-    WebIDBDatabase* database = map_.Lookup(iter->first);
+    WebIDBDatabaseImpl* database = map_.Lookup(iter->first);
     if (database) {
       database->close();
       parent_->Context()->ConnectionClosed(iter->second, database);
     }
   }
 }
 
 bool IndexedDBDispatcherHost::DatabaseDispatcherHost::OnMessageReceived(
     const IPC::Message& message,
     bool* msg_is_ok) {
@@ skipping 27 matching lines @@
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::Send(
     IPC::Message* message) {
   parent_->Send(message);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateObjectStore(
     const IndexedDBHostMsg_DatabaseCreateObjectStore_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   database->createObjectStore(host_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(
         host_transaction_id,
         WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError));
   }
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
 
   database->deleteObjectStore(parent_->HostTransactionId(transaction_id),
                               object_store_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateTransaction(
     const IndexedDBHostMsg_DatabaseCreateTransaction_Params& params) {
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
   WebVector<long long> object_stores(params.object_store_ids.size());
   for (size_t i = 0; i < params.object_store_ids.size(); ++i)
     object_stores[i] = params.object_store_ids[i];
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
 
   database->createTransaction(
       host_transaction_id,
       new IndexedDBDatabaseCallbacks(
           parent_, params.ipc_thread_id, params.ipc_database_callbacks_id),
       object_stores,
       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) {
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
   database->close();
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDestroyed(
     int32 ipc_object_id) {
-  WebIDBDatabase* database = map_.Lookup(ipc_object_id);
+  WebIDBDatabaseImpl* database = map_.Lookup(ipc_object_id);
   parent_->Context()
       ->ConnectionClosed(database_url_map_[ipc_object_id], database);
   database_url_map_.erase(ipc_object_id);
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGet(
     const IndexedDBHostMsg_DatabaseGet_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<WebIDBCallbacks> callbacks(new IndexedDBCallbacks<WebData>(
+  scoped_ptr<IndexedDBCallbacksBase> callbacks(new IndexedDBCallbacks<WebData>(
       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());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
     const IndexedDBHostMsg_DatabasePut_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
 
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
-  scoped_ptr<WebIDBCallbacks> callbacks(new IndexedDBCallbacks<WebIDBKey>(
-      parent_, params.ipc_thread_id, params.ipc_callbacks_id));
+  scoped_ptr<IndexedDBCallbacksBase> callbacks(
+      new IndexedDBCallbacks<WebIDBKey>(
+          parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   // Be careful with empty vectors.
   WebData value;
   if (params.value.size())
     value.assign(&params.value.front(), params.value.size());
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   database->put(host_transaction_id,
                 params.object_store_id,
                 value,
                 params.key,
                 params.put_mode,
                 callbacks.release(),
                 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(
     const IndexedDBHostMsg_DatabaseSetIndexKeys_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   if (params.index_ids.size() != params.index_keys.size()) {
     database->abort(
         host_transaction_id,
         WebIDBDatabaseError(
             WebKit::WebIDBDatabaseExceptionUnknownError,
             "Malformed IPC message: index_ids.size() != index_keys.size()"));
     return;
   }
 
   database->setIndexKeys(host_transaction_id,
                          params.object_store_id,
                          params.primary_key,
                          params.index_ids,
                          params.index_keys);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexesReady(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     const std::vector<int64>& index_ids) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
 
   database->setIndexesReady(parent_->HostTransactionId(transaction_id),
                             object_store_id,
                             WebVector<long long>(index_ids));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnOpenCursor(
     const IndexedDBHostMsg_DatabaseOpenCursor_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<WebIDBCallbacks> callbacks(new IndexedDBCallbacks<WebIDBCursor>(
-      parent_, params.ipc_thread_id, params.ipc_callbacks_id, -1));
+  scoped_ptr<IndexedDBCallbacksBase> callbacks(
+      new IndexedDBCallbacks<WebIDBCursorImpl>(
+          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());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCount(
     const IndexedDBHostMsg_DatabaseCount_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<WebIDBCallbacks> callbacks(new IndexedDBCallbacks<WebData>(
+  scoped_ptr<IndexedDBCallbacksBase> callbacks(new IndexedDBCallbacks<WebData>(
       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());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteRange(
     const IndexedDBHostMsg_DatabaseDeleteRange_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<WebIDBCallbacks> callbacks(new IndexedDBCallbacks<WebData>(
+  scoped_ptr<IndexedDBCallbacksBase> callbacks(new IndexedDBCallbacks<WebData>(
       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());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClear(
     int32 ipc_thread_id,
     int32 ipc_callbacks_id,
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
 
-  scoped_ptr<WebIDBCallbacks> callbacks(new IndexedDBCallbacks<WebData>(
+  scoped_ptr<IndexedDBCallbacksBase> callbacks(new IndexedDBCallbacks<WebData>(
       parent_, ipc_thread_id, ipc_callbacks_id));
 
   database->clear(parent_->HostTransactionId(transaction_id),
                   object_store_id,
                   callbacks.release());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnAbort(
     int32 ipc_database_id,
     int64 transaction_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
 
   database->abort(parent_->HostTransactionId(transaction_id));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCommit(
     int32 ipc_database_id,
     int64 transaction_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(transaction_id);
   int64 transaction_size = transaction_size_map_[host_transaction_id];
   if (transaction_size &&
       parent_->Context()->WouldBeOverQuota(
           transaction_url_map_[host_transaction_id], transaction_size)) {
     database->abort(
         host_transaction_id,
         WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError));
     return;
   }
 
   database->commit(host_transaction_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateIndex(
     const IndexedDBHostMsg_DatabaseCreateIndex_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBDatabase* database =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   database->createIndex(host_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(
         host_transaction_id,
         WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError));
   }
 }
 
 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 =
+  WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!database)
     return;
 
   database->deleteIndex(
       parent_->HostTransactionId(transaction_id), object_store_id, index_id);
 }
 
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::CursorDispatcherHost
@@ skipping 27 matching lines @@
     IPC::Message* message) {
   parent_->Send(message);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnAdvance(
     int32 ipc_cursor_id,
     int32 ipc_thread_id,
     int32 ipc_callbacks_id,
     unsigned long count) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBCursor* idb_cursor =
+  WebIDBCursorImpl* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->advance(
       count,
-      new IndexedDBCallbacks<WebIDBCursor>(
+      new IndexedDBCallbacks<WebIDBCursorImpl>(
           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(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBCursor* idb_cursor =
+  WebIDBCursorImpl* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->continueFunction(
       key,
-      new IndexedDBCallbacks<WebIDBCursor>(
+      new IndexedDBCallbacks<WebIDBCursorImpl>(
           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(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBCursor* idb_cursor =
+  WebIDBCursorImpl* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->prefetchContinue(
       n,
-      new IndexedDBCallbacks<WebIDBCursor>(
+      new IndexedDBCallbacks<WebIDBCursorImpl>(
           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(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  WebIDBCursor* idb_cursor =
+  WebIDBCursorImpl* 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) {
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content