IndexedDB: Remove IndexedDBCallbacksWrapper

content/browser/indexed_db/indexed_db_database.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/indexed_db_database.h"
 
 #include <math.h>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 45 matching lines @@
   const IndexedDBObjectStoreMetadata object_store_metadata_;
 };
 
 class IndexedDBDatabase::VersionChangeOperation
     : public IndexedDBTransaction::Operation {
  public:
   VersionChangeOperation(
       scoped_refptr<IndexedDBDatabase> database,
       int64 transaction_id,
       int64 version,
-      scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+      scoped_refptr<IndexedDBCallbacks> callbacks,
       scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
       WebKit::WebIDBCallbacks::DataLoss data_loss)
       : database_(database),
         transaction_id_(transaction_id),
         version_(version),
         callbacks_(callbacks),
         database_callbacks_(database_callbacks),
         data_loss_(data_loss) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   scoped_refptr<IndexedDBDatabase> database_;
   int64 transaction_id_;
   int64 version_;
-  scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  scoped_refptr<IndexedDBCallbacks> callbacks_;
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks_;
   WebKit::WebIDBCallbacks::DataLoss data_loss_;
 };
 
 class CreateObjectStoreAbortOperation : public IndexedDBTransaction::Operation {
  public:
   CreateObjectStoreAbortOperation(scoped_refptr<IndexedDBDatabase> database,
                                   int64 object_store_id)
       : database_(database), object_store_id_(object_store_id) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
@@ skipping 100 matching lines @@
 class GetOperation : public IndexedDBTransaction::Operation {
  public:
   GetOperation(scoped_refptr<IndexedDBBackingStore> backing_store,
                int64 database_id,
                int64 object_store_id,
                int64 index_id,
                const IndexedDBKeyPath& key_path,
                const bool auto_increment,
                scoped_ptr<IndexedDBKeyRange> key_range,
                indexed_db::CursorType cursor_type,
-               scoped_refptr<IndexedDBCallbacksWrapper> callbacks)
+               scoped_refptr<IndexedDBCallbacks> callbacks)
       : backing_store_(backing_store),
         database_id_(database_id),
         object_store_id_(object_store_id),
         index_id_(index_id),
         key_path_(key_path),
         auto_increment_(auto_increment),
         key_range_(key_range.Pass()),
         cursor_type_(cursor_type),
-        callbacks_(callbacks) {
-  }
+        callbacks_(callbacks) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const int64 database_id_;
   const int64 object_store_id_;
   const int64 index_id_;
   const IndexedDBKeyPath key_path_;
   const bool auto_increment_;
   const scoped_ptr<IndexedDBKeyRange> key_range_;
   const indexed_db::CursorType cursor_type_;
-  const scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  const scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 class PutOperation : public IndexedDBTransaction::Operation {
  public:
   PutOperation(scoped_refptr<IndexedDBBackingStore> backing_store,
                int64 database_id,
                const IndexedDBObjectStoreMetadata& object_store,
                std::vector<char>* value,
                scoped_ptr<IndexedDBKey> key,
                IndexedDBDatabase::PutMode put_mode,
-               scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+               scoped_refptr<IndexedDBCallbacks> callbacks,
                const std::vector<int64>& index_ids,
                const std::vector<IndexedDBDatabase::IndexKeys>& index_keys)
       : backing_store_(backing_store),
         database_id_(database_id),
         object_store_(object_store),
         key_(key.Pass()),
         put_mode_(put_mode),
         callbacks_(callbacks),
         index_ids_(index_ids),
         index_keys_(index_keys) {
     value_.swap(*value);
   }
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const int64 database_id_;
   const IndexedDBObjectStoreMetadata object_store_;
   std::vector<char> value_;
   scoped_ptr<IndexedDBKey> key_;
   const IndexedDBDatabase::PutMode put_mode_;
-  const scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  const scoped_refptr<IndexedDBCallbacks> callbacks_;
   const std::vector<int64> index_ids_;
   const std::vector<IndexedDBDatabase::IndexKeys> index_keys_;
 };
 
 class SetIndexesReadyOperation : public IndexedDBTransaction::Operation {
  public:
   explicit SetIndexesReadyOperation(size_t index_count)
       : index_count_(index_count) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const size_t index_count_;
 };
 
 class OpenCursorOperation : public IndexedDBTransaction::Operation {
  public:
   OpenCursorOperation(scoped_refptr<IndexedDBBackingStore> backing_store,
                       int64 database_id,
                       int64 object_store_id,
                       int64 index_id,
                       scoped_ptr<IndexedDBKeyRange> key_range,
                       indexed_db::CursorDirection direction,
                       indexed_db::CursorType cursor_type,
                       IndexedDBDatabase::TaskType task_type,
-                      scoped_refptr<IndexedDBCallbacksWrapper> callbacks)
+                      scoped_refptr<IndexedDBCallbacks> callbacks)
       : backing_store_(backing_store),
         database_id_(database_id),
         object_store_id_(object_store_id),
         index_id_(index_id),
         key_range_(key_range.Pass()),
         direction_(direction),
         cursor_type_(cursor_type),
         task_type_(task_type),
         callbacks_(callbacks) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const int64 database_id_;
   const int64 object_store_id_;
   const int64 index_id_;
   const scoped_ptr<IndexedDBKeyRange> key_range_;
   const indexed_db::CursorDirection direction_;
   const indexed_db::CursorType cursor_type_;
   const IndexedDBDatabase::TaskType task_type_;
-  const scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  const scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 class CountOperation : public IndexedDBTransaction::Operation {
  public:
   CountOperation(scoped_refptr<IndexedDBBackingStore> backing_store,
                  int64 database_id,
                  int64 object_store_id,
                  int64 index_id,
                  scoped_ptr<IndexedDBKeyRange> key_range,
-                 scoped_refptr<IndexedDBCallbacksWrapper> callbacks)
+                 scoped_refptr<IndexedDBCallbacks> callbacks)
       : backing_store_(backing_store),
         database_id_(database_id),
         object_store_id_(object_store_id),
         index_id_(index_id),
         key_range_(key_range.Pass()),
         callbacks_(callbacks) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const int64 database_id_;
   const int64 object_store_id_;
   const int64 index_id_;
   const scoped_ptr<IndexedDBKeyRange> key_range_;
-  const scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  const scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 class DeleteRangeOperation : public IndexedDBTransaction::Operation {
  public:
   DeleteRangeOperation(scoped_refptr<IndexedDBBackingStore> backing_store,
                        int64 database_id,
                        int64 object_store_id,
                        scoped_ptr<IndexedDBKeyRange> key_range,
-                       scoped_refptr<IndexedDBCallbacksWrapper> callbacks)
+                       scoped_refptr<IndexedDBCallbacks> callbacks)
       : backing_store_(backing_store),
         database_id_(database_id),
         object_store_id_(object_store_id),
         key_range_(key_range.Pass()),
         callbacks_(callbacks) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const int64 database_id_;
   const int64 object_store_id_;
   const scoped_ptr<IndexedDBKeyRange> key_range_;
-  const scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  const scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 class ClearOperation : public IndexedDBTransaction::Operation {
  public:
   ClearOperation(scoped_refptr<IndexedDBBackingStore> backing_store,
                  int64 database_id,
                  int64 object_store_id,
-                 scoped_refptr<IndexedDBCallbacksWrapper> callbacks)
+                 scoped_refptr<IndexedDBCallbacks> callbacks)
       : backing_store_(backing_store),
         database_id_(database_id),
         object_store_id_(object_store_id),
         callbacks_(callbacks) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const int64 database_id_;
   const int64 object_store_id_;
-  const scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  const scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 class IndexedDBDatabase::PendingOpenCall {
  public:
-  PendingOpenCall(
-      scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
-      scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
-      int64 transaction_id,
-      int64 version)
+  PendingOpenCall(scoped_refptr<IndexedDBCallbacks> callbacks,
+                  scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+                  int64 transaction_id,
+                  int64 version)
       : callbacks_(callbacks),
         database_callbacks_(database_callbacks),
         version_(version),
         transaction_id_(transaction_id) {}
-  scoped_refptr<IndexedDBCallbacksWrapper> Callbacks() { return callbacks_; }
+  scoped_refptr<IndexedDBCallbacks> Callbacks() { return callbacks_; }
   scoped_refptr<IndexedDBDatabaseCallbacks> DatabaseCallbacks() {
     return database_callbacks_;
   }
   int64 Version() { return version_; }
   int64 TransactionId() const { return transaction_id_; }
 
  private:
-  scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  scoped_refptr<IndexedDBCallbacks> callbacks_;
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks_;
   int64 version_;
   const int64 transaction_id_;
 };
 
 class IndexedDBDatabase::PendingDeleteCall {
  public:
-  explicit PendingDeleteCall(scoped_refptr<IndexedDBCallbacksWrapper> callbacks)
+  explicit PendingDeleteCall(scoped_refptr<IndexedDBCallbacks> callbacks)
       : callbacks_(callbacks) {}
-  scoped_refptr<IndexedDBCallbacksWrapper> Callbacks() { return callbacks_; }
+  scoped_refptr<IndexedDBCallbacks> Callbacks() { return callbacks_; }
 
  private:
-  scoped_refptr<IndexedDBCallbacksWrapper> callbacks_;
+  scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 scoped_refptr<IndexedDBDatabase> IndexedDBDatabase::Create(
     const string16& name,
     IndexedDBBackingStore* database,
     IndexedDBFactory* factory,
     const string16& unique_identifier) {
   scoped_refptr<IndexedDBDatabase> backend =
       new IndexedDBDatabase(name, database, factory, unique_identifier);
   if (!backend->OpenInternal())
@@ skipping 280 matching lines @@
 }
 
 void IndexedDBDatabase::Abort(int64 transaction_id,
                               const IndexedDBDatabaseError& error) {
   // If the transaction is unknown, then it has already been aborted by the
   // backend before this call so it is safe to ignore it.
   if (transactions_.find(transaction_id) != transactions_.end())
     transactions_[transaction_id]->Abort(error);
 }
 
-void IndexedDBDatabase::Get(
-    int64 transaction_id,
-    int64 object_store_id,
-    int64 index_id,
-    scoped_ptr<IndexedDBKeyRange> key_range,
-    bool key_only,
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
+void IndexedDBDatabase::Get(int64 transaction_id,
+                            int64 object_store_id,
+                            int64 index_id,
+                            scoped_ptr<IndexedDBKeyRange> key_range,
+                            bool key_only,
+                            scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBDatabase::Get");
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return;
   IndexedDBDatabaseMetadata::ObjectStoreMap::const_iterator store_iterator =
       metadata_.object_stores.find(object_store_id);
   if (store_iterator == metadata_.object_stores.end())
     return;
   IndexedDBTransaction* transaction = trans_iterator->second;
@@ skipping 175 matching lines @@
       object_store_id,
       static_cast<int64>(floor(key->number())) + 1,
       check_current);
 }
 
 void IndexedDBDatabase::Put(int64 transaction_id,
                             int64 object_store_id,
                             std::vector<char>* value,
                             scoped_ptr<IndexedDBKey> key,
                             PutMode put_mode,
-                            scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+                            scoped_refptr<IndexedDBCallbacks> callbacks,
                             const std::vector<int64>& index_ids,
                             const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE("IndexedDBDatabase::Put");
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return;
   IndexedDBTransaction* transaction = trans_iterator->second;
   DCHECK_NE(transaction->mode(), indexed_db::TRANSACTION_READ_ONLY);
 
@@ skipping 58 matching lines @@
       callbacks_->OnError(
           IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionConstraintError,
                                  "Key already exists in the object store."));
       return;
     }
   }
 
   ScopedVector<IndexWriter> index_writers;
   string16 error_message;
   bool obeys_constraints = false;
-  bool backing_store_success =
-      MakeIndexWriters(transaction,
-                                                 backing_store_.get(),
-                                                 database_id_,
-                                                 object_store_,
-                                                 *key,
-                                                 key_was_generated,
-                                                 index_ids_,
-                                                 index_keys_,
-                                                 &index_writers,
-                                                 &error_message,
-                                                 &obeys_constraints);
+  bool backing_store_success = MakeIndexWriters(transaction,
+                                                backing_store_.get(),
+                                                database_id_,
+                                                object_store_,
+                                                *key,
+                                                key_was_generated,
+                                                index_ids_,
+                                                index_keys_,
+                                                &index_writers,
+                                                &error_message,
+                                                &obeys_constraints);
   if (!backing_store_success) {
     callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error updating index keys."));
     return;
   }
   if (!obeys_constraints) {
     callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionConstraintError, error_message));
     return;
@@ skipping 144 matching lines @@
 }
 
 void IndexedDBDatabase::OpenCursor(
     int64 transaction_id,
     int64 object_store_id,
     int64 index_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     indexed_db::CursorDirection direction,
     bool key_only,
     TaskType task_type,
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
+    scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBDatabase::OpenCursor");
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return;
   IndexedDBTransaction* transaction = trans_iterator->second;
 
   transaction->ScheduleTask(new OpenCursorOperation(
       backing_store_,
       id(),
@@ skipping 52 matching lines @@
   }
 
   IndexedDBDatabase::TaskType task_type(
       static_cast<IndexedDBDatabase::TaskType>(task_type_));
   scoped_refptr<IndexedDBCursor> cursor = IndexedDBCursor::Create(
       backing_store_cursor.Pass(), cursor_type_, task_type, transaction);
   callbacks_->OnSuccess(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
 }
 
-void IndexedDBDatabase::Count(
-    int64 transaction_id,
-    int64 object_store_id,
-    int64 index_id,
-    scoped_ptr<IndexedDBKeyRange> key_range,
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
+void IndexedDBDatabase::Count(int64 transaction_id,
+                              int64 object_store_id,
+                              int64 index_id,
+                              scoped_ptr<IndexedDBKeyRange> key_range,
+                              scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBDatabase::Count");
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return;
   IndexedDBTransaction* transaction = trans_iterator->second;
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   transaction->ScheduleTask(new CountOperation(backing_store_,
@@ skipping 34 matching lines @@
     ++count;
   } while (backing_store_cursor->ContinueFunction());
 
   callbacks_->OnSuccess(count);
 }
 
 void IndexedDBDatabase::DeleteRange(
     int64 transaction_id,
     int64 object_store_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
+    scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBDatabase::DeleteRange");
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return;
   IndexedDBTransaction* transaction = trans_iterator->second;
 
   transaction->ScheduleTask(new DeleteRangeOperation(
       backing_store_, id(), object_store_id, key_range.Pass(), callbacks));
 }
@@ skipping 18 matching lines @@
             IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error deleting data in range"));
         return;
       }
     } while (backing_store_cursor->ContinueFunction());
   }
 
   callbacks_->OnSuccess();
 }
 
-void IndexedDBDatabase::Clear(
-    int64 transaction_id,
-    int64 object_store_id,
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
+void IndexedDBDatabase::Clear(int64 transaction_id,
+                              int64 object_store_id,
+                              scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBDatabase::Clear");
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return;
   IndexedDBTransaction* transaction = trans_iterator->second;
   DCHECK_NE(transaction->mode(), indexed_db::TRANSACTION_READ_ONLY);
 
   transaction->ScheduleTask(
       new ClearOperation(backing_store_, id(), object_store_id, callbacks));
@@ skipping 181 matching lines @@
   transactions_[transaction_id] = transaction.get();
 }
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
          pending_run_version_change_transaction_call_;
 }
 
 void IndexedDBDatabase::OpenConnection(
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+    scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 version) {
   const WebKit::WebIDBCallbacks::DataLoss kDataLoss =
       WebKit::WebIDBCallbacks::DataLossNone;
   OpenConnection(
       callbacks, database_callbacks, transaction_id, version, kDataLoss);
 }
 
 void IndexedDBDatabase::OpenConnection(
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+    scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 version,
     WebKit::WebIDBCallbacks::DataLoss data_loss) {
   DCHECK(backing_store_.get());
 
   // TODO(jsbell): Should have a priority queue so that higher version
   // requests are processed first. http://crbug.com/225850
   if (IsOpenConnectionBlocked()) {
     // The backing store only detects data loss when it is first opened. The
@@ skipping 66 matching lines @@
             ASCIIToUTF16(") is less than the existing version (") +
             Int64ToString16(metadata_.int_version) + ASCIIToUTF16(").")));
     return;
   }
   DCHECK_EQ(version, metadata_.int_version);
   database_callbacks_set_.insert(database_callbacks);
   callbacks->OnSuccess(this, this->metadata());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+    scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 requested_version,
     WebKit::WebIDBCallbacks::DataLoss data_loss) {
 
   DCHECK(callbacks.get());
   DCHECK(database_callbacks_set_.has(database_callbacks));
   if (ConnectionCount() > 1) {
     DCHECK_NE(WebKit::WebIDBCallbacks::DataLossTotal, data_loss);
     // Front end ensures the event is not fired at connections that have
@@ skipping 16 matching lines @@
     return;
   }
   RunVersionChangeTransactionFinal(callbacks,
                                    database_callbacks,
                                    transaction_id,
                                    requested_version,
                                    data_loss);
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+    scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 requested_version) {
   const WebKit::WebIDBCallbacks::DataLoss kDataLoss =
       WebKit::WebIDBCallbacks::DataLossNone;
   RunVersionChangeTransactionFinal(callbacks,
                                    database_callbacks,
                                    transaction_id,
                                    requested_version,
                                    kDataLoss);
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
+    scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 requested_version,
     WebKit::WebIDBCallbacks::DataLoss data_loss) {
 
   std::vector<int64> object_store_ids;
   CreateTransaction(transaction_id,
                     database_callbacks,
                     object_store_ids,
                     indexed_db::TRANSACTION_VERSION_CHANGE);
   scoped_refptr<IndexedDBTransaction> transaction =
       transactions_[transaction_id];
 
   transaction->ScheduleTask(
       new VersionChangeOperation(this,
                                  transaction_id,
                                  requested_version,
                                  callbacks,
                                  database_callbacks,
                                  data_loss),
       new VersionChangeAbortOperation(
           this, metadata_.version, metadata_.int_version));
 
   DCHECK(!pending_second_half_open_);
 }
 
 void IndexedDBDatabase::DeleteDatabase(
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
+    scoped_refptr<IndexedDBCallbacks> callbacks) {
 
   if (IsDeleteDatabaseBlocked()) {
     for (DatabaseCallbacksSet::const_iterator it =
              database_callbacks_set_.begin();
          it != database_callbacks_set_.end();
          ++it) {
       // Front end ensures the event is not fired at connections that have
       // close_pending set.
       (*it)->OnVersionChange(metadata_.int_version,
                              IndexedDBDatabaseMetadata::NO_INT_VERSION);
     }
     // TODO(jsbell): Only fire OnBlocked if there are open
     // connections after the VersionChangeEvents are received, not
     // just set up to fire.  http://crbug.com/100123
     callbacks->OnBlocked(metadata_.int_version);
     pending_delete_calls_.push_back(new PendingDeleteCall(callbacks));
     return;
   }
   DeleteDatabaseFinal(callbacks);
 }
 
 bool IndexedDBDatabase::IsDeleteDatabaseBlocked() const {
   return !!ConnectionCount();
 }
 
 void IndexedDBDatabase::DeleteDatabaseFinal(
-    scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
+    scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(!IsDeleteDatabaseBlocked());
   DCHECK(backing_store_.get());
   if (!backing_store_->DeleteDatabase(metadata_.name)) {
     callbacks->OnError(
         IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                "Internal error deleting database."));
     return;
   }
   metadata_.version = kNoStringVersion;
   metadata_.id = kInvalidId;
@@ skipping 75 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation::Perform(
     IndexedDBTransaction* transaction) {
   IDB_TRACE("VersionChangeAbortOperation");
   DCHECK(!transaction);
   database_->metadata_.version = previous_version_;
   database_->metadata_.int_version = previous_int_version_;
 }
 
 }  // namespace content