Proxy new WebData-based onSuccess() calls.

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 30 matching lines @@
 using WebKit::WebExceptionCode;
 using WebKit::WebIDBCallbacks;
 using WebKit::WebIDBCursor;
 using WebKit::WebIDBDatabase;
 using WebKit::WebIDBDatabaseError;
 using WebKit::WebIDBIndex;
 using WebKit::WebIDBKey;
 using WebKit::WebIDBMetadata;
 using WebKit::WebIDBObjectStore;
 using WebKit::WebSecurityOrigin;
-using WebKit::WebSerializedScriptValue;
 using WebKit::WebVector;
 
 namespace content {
 namespace {
 
 template <class T>
 void DeleteOnWebKitThread(T* obj) {
   if (!BrowserThread::DeleteSoon(BrowserThread::WEBKIT_DEPRECATED,
                                  FROM_HERE, obj))
     delete obj;
@@ skipping 206 matching lines @@
       origin, NULL, webkit_base::FilePathToWebString(indexed_db_path));
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryDeleteDatabase(
     const IndexedDBHostMsg_FactoryDeleteDatabase_Params& params) {
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   Context()->GetIDBFactory()->deleteDatabase(
       params.name,
-      new IndexedDBCallbacks<WebSerializedScriptValue>(this,
-                                                       params.ipc_thread_id,
-                                                       params.ipc_response_id),
+      new IndexedDBCallbacks<WebData>(this,
+                                      params.ipc_thread_id,
+                                      params.ipc_response_id),
       WebSecurityOrigin::createFromDatabaseIdentifier(params.origin), NULL,
       webkit_base::FilePathToWebString(indexed_db_path));
 }
 
 void IndexedDBDispatcherHost::FinishTransaction(
     int64 host_transaction_id, bool committed) {
   if (committed)
     Context()->TransactionComplete(
         database_dispatcher_host_->transaction_url_map_[host_transaction_id]);
   database_dispatcher_host_->transaction_url_map_.erase(host_transaction_id);
@@ skipping 169 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGet(
     const IndexedDBHostMsg_DatabaseGet_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBDatabase* database = parent_->GetOrTerminateProcess(
       &map_, params.ipc_database_id);
   if (!database)
     return;
 
   scoped_ptr<WebIDBCallbacks> callbacks(
-      new IndexedDBCallbacks<WebSerializedScriptValue>(
+      new IndexedDBCallbacks<WebData>(
           parent_, params.ipc_thread_id,
           params.ipc_response_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) {
@@ skipping 82 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCount(
     const IndexedDBHostMsg_DatabaseCount_Params& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBDatabase* database = parent_->GetOrTerminateProcess(
       &map_, params.ipc_database_id);
   if (!database)
     return;
 
   scoped_ptr<WebIDBCallbacks> callbacks(
-      new IndexedDBCallbacks<WebSerializedScriptValue>(
+      new IndexedDBCallbacks<WebData>(
           parent_, params.ipc_thread_id,
           params.ipc_response_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 = parent_->GetOrTerminateProcess(
       &map_, params.ipc_database_id);
   if (!database)
     return;
 
   scoped_ptr<WebIDBCallbacks> callbacks(
-      new IndexedDBCallbacks<WebSerializedScriptValue>(
+      new IndexedDBCallbacks<WebData>(
           parent_, params.ipc_thread_id,
           params.ipc_response_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_response_id,
     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;
 
   scoped_ptr<WebIDBCallbacks> callbacks(
-      new IndexedDBCallbacks<WebSerializedScriptValue>(
+      new IndexedDBCallbacks<WebData>(
           parent_, ipc_thread_id,
           ipc_response_id));
 
   database->clear(parent_->HostTransactionId(transaction_id),
                   object_store_id, callbacks.release());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnAbort(
     int32 ipc_database_id,
     int64 transaction_id) {
@@ skipping 176 matching lines @@
     int32 ipc_thread_id,
     int32 ipc_response_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(&map_,
                                                             ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   WebKit::WebExceptionCode ec = 0;
   idb_cursor->deleteFunction(
-      new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, ipc_thread_id,
-                                                       ipc_response_id), ec);
+      new IndexedDBCallbacks<WebData>(parent_, ipc_thread_id,
+                                      ipc_response_id), ec);
   DCHECK(!ec);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32 ipc_object_id) {
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content