IndexedDB: Remove IndexedDBCallbacksWrapper

content/browser/indexed_db/webidbdatabase_impl.cc

 // Copyright (c) 2013 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/webidbdatabase_impl.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
-#include "content/browser/indexed_db/indexed_db_callbacks_wrapper.h"
+#include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
-#include "content/browser/indexed_db/indexed_db_database.h"
-#include "content/browser/indexed_db/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_database_error.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
 
 namespace content {
 
 WebIDBDatabaseImpl::WebIDBDatabaseImpl(
     scoped_refptr<IndexedDBDatabase> database_backend,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks)
     : database_backend_(database_backend),
@@ skipping 54 matching lines @@
                                const IndexedDBDatabaseError& error) {
   if (database_backend_.get())
     database_backend_->Abort(transaction_id, error);
 }
 
 void WebIDBDatabaseImpl::commit(long long transaction_id) {
   if (database_backend_.get())
     database_backend_->Commit(transaction_id);
 }
 
-void WebIDBDatabaseImpl::openCursor(long long transaction_id,
-                                    long long object_store_id,
-                                    long long index_id,
-                                    const IndexedDBKeyRange& key_range,
-                                    unsigned short direction,
-                                    bool key_only,
-                                    WebKit::WebIDBDatabase::TaskType task_type,
-                                    IndexedDBCallbacksBase* callbacks) {
+void WebIDBDatabaseImpl::openCursor(
+    long long transaction_id,
+    long long object_store_id,
+    long long index_id,
+    const IndexedDBKeyRange& key_range,
+    unsigned short direction,
+    bool key_only,
+    WebKit::WebIDBDatabase::TaskType task_type,
+    scoped_refptr<IndexedDBCallbacks> callbacks) {
   if (database_backend_.get())
     database_backend_->OpenCursor(
         transaction_id,
         object_store_id,
         index_id,
         make_scoped_ptr(new IndexedDBKeyRange(key_range)),
         static_cast<indexed_db::CursorDirection>(direction),
         key_only,
         static_cast<IndexedDBDatabase::TaskType>(task_type),
-        IndexedDBCallbacksWrapper::Create(callbacks));
+        callbacks);
 }
 
 void WebIDBDatabaseImpl::count(long long transaction_id,
                                long long object_store_id,
                                long long index_id,
                                const IndexedDBKeyRange& key_range,
-                               IndexedDBCallbacksBase* callbacks) {
+                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   if (database_backend_.get())
     database_backend_->Count(transaction_id,
                              object_store_id,
                              index_id,
                              make_scoped_ptr(new IndexedDBKeyRange(key_range)),
-                             IndexedDBCallbacksWrapper::Create(callbacks));
+                             callbacks);
 }
 
 void WebIDBDatabaseImpl::get(long long transaction_id,
                              long long object_store_id,
                              long long index_id,
                              const IndexedDBKeyRange& key_range,
                              bool key_only,
-                             IndexedDBCallbacksBase* callbacks) {
+                             scoped_refptr<IndexedDBCallbacks> callbacks) {
   if (database_backend_.get())
     database_backend_->Get(transaction_id,
                            object_store_id,
                            index_id,
                            make_scoped_ptr(new IndexedDBKeyRange(key_range)),
                            key_only,
-                           IndexedDBCallbacksWrapper::Create(callbacks));
+                           callbacks);
 }
 
 void WebIDBDatabaseImpl::put(long long transaction_id,
                              long long object_store_id,
                              std::vector<char>* value,
                              const IndexedDBKey& key,
                              WebKit::WebIDBDatabase::PutMode put_mode,
-                             IndexedDBCallbacksBase* callbacks,
+                             scoped_refptr<IndexedDBCallbacks> callbacks,
                              const std::vector<int64>& index_ids,
                              const std::vector<IndexKeys>& index_keys) {
   if (!database_backend_.get())
     return;
 
   DCHECK_EQ(index_ids.size(), index_keys.size());
 
   database_backend_->Put(transaction_id,
                          object_store_id,
                          value,
                          make_scoped_ptr(new IndexedDBKey(key)),
                          static_cast<IndexedDBDatabase::PutMode>(put_mode),
-                         IndexedDBCallbacksWrapper::Create(callbacks),
+                         callbacks,
                          index_ids,
                          index_keys);
 }
 
 void WebIDBDatabaseImpl::setIndexKeys(
     long long transaction_id,
     long long object_store_id,
     const IndexedDBKey& primary_key,
     const std::vector<int64>& index_ids,
     const std::vector<IndexKeys>& index_keys) {
@@ skipping 16 matching lines @@
   if (!database_backend_.get())
     return;
 
   std::vector<int64> index_ids(web_index_ids.size());
   for (size_t i = 0; i < web_index_ids.size(); ++i)
     index_ids[i] = web_index_ids[i];
   database_backend_->SetIndexesReady(
       transaction_id, object_store_id, index_ids);
 }
 
-void WebIDBDatabaseImpl::deleteRange(long long transaction_id,
-                                     long long object_store_id,
-                                     const IndexedDBKeyRange& key_range,
-                                     IndexedDBCallbacksBase* callbacks) {
+void WebIDBDatabaseImpl::deleteRange(
+    long long transaction_id,
+    long long object_store_id,
+    const IndexedDBKeyRange& key_range,
+    scoped_refptr<IndexedDBCallbacks> callbacks) {
   if (database_backend_.get())
     database_backend_->DeleteRange(
         transaction_id,
         object_store_id,
         make_scoped_ptr(new IndexedDBKeyRange(key_range)),
-        IndexedDBCallbacksWrapper::Create(callbacks));
+        callbacks);
 }
 
 void WebIDBDatabaseImpl::clear(long long transaction_id,
                                long long object_store_id,
-                               IndexedDBCallbacksBase* callbacks) {
+                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   if (database_backend_.get())
-    database_backend_->Clear(transaction_id,
-                             object_store_id,
-                             IndexedDBCallbacksWrapper::Create(callbacks));
+    database_backend_->Clear(transaction_id, object_store_id, callbacks);
 }
 
 void WebIDBDatabaseImpl::createIndex(long long transaction_id,
                                      long long object_store_id,
                                      long long index_id,
                                      const string16& name,
                                      const IndexedDBKeyPath& key_path,
                                      bool unique,
                                      bool multi_entry) {
   if (database_backend_.get())
     database_backend_->CreateIndex(transaction_id,
                                    object_store_id,
                                    index_id,
                                    name,
                                    IndexedDBKeyPath(key_path),
                                    unique,
                                    multi_entry);
 }
 
 void WebIDBDatabaseImpl::deleteIndex(long long transaction_id,
                                      long long object_store_id,
                                      long long index_id) {
   if (database_backend_.get())
     database_backend_->DeleteIndex(transaction_id, object_store_id, index_id);
 }
 
 }  // namespace WebKit