Replacing Indexed DB Chromium IPC with Mojo

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 <limits>
 #include <memory>
@@ skipping 13 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_class_factory.h"
 #include "content/browser/indexed_db/indexed_db_connection.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_factory.h"
 #include "content/browser/indexed_db/indexed_db_index_writer.h"
 #include "content/browser/indexed_db/indexed_db_observation.h"
 #include "content/browser/indexed_db/indexed_db_observer_changes.h"
+#include "content/browser/indexed_db/indexed_db_open_request_observer.h"
 #include "content/browser/indexed_db/indexed_db_pending_connection.h"
+#include "content/browser/indexed_db/indexed_db_pending_delete.h"
 #include "content/browser/indexed_db/indexed_db_return_value.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/common/indexed_db/indexed_db_constants.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
 #include "content/public/common/content_switches.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
@@ skipping 75 matching lines @@
               std::unique_ptr<IndexedDBPendingConnection> pending_connection)
       : ConnectionRequest(db), pending_(std::move(pending_connection)) {}
 
   void Perform() override {
     if (db_->metadata_.id == kInvalidId) {
       // The database was deleted then immediately re-opened; OpenInternal()
       // recreates it in the backing store.
       if (!db_->OpenInternal().ok()) {
         // TODO(jsbell): Consider including sanitized leveldb status message.
         base::string16 message;
-        if (pending_->version == IndexedDBDatabaseMetadata::NO_VERSION) {
+        if (pending_->version() == IndexedDBDatabaseMetadata::NO_VERSION) {
           message = ASCIIToUTF16(
               "Internal error opening database with no version specified.");
         } else {
           message =
               ASCIIToUTF16("Internal error opening database with version ") +
-              Int64ToString16(pending_->version);
+              Int64ToString16(pending_->version());
         }
-        pending_->callbacks->OnError(IndexedDBDatabaseError(
+        pending_->OnError(IndexedDBDatabaseError(
             blink::WebIDBDatabaseExceptionUnknownError, message));
         db_->RequestComplete(this);
         return;
       }
 
       DCHECK_EQ(IndexedDBDatabaseMetadata::NO_VERSION, db_->metadata_.version);
     }
 
     const int64_t old_version = db_->metadata_.version;
-    int64_t& new_version = pending_->version;
 
     bool is_new_database = old_version == IndexedDBDatabaseMetadata::NO_VERSION;
 
-    if (new_version == IndexedDBDatabaseMetadata::DEFAULT_VERSION) {
+    if (pending_->version() == IndexedDBDatabaseMetadata::DEFAULT_VERSION) {
       // For unit tests only - skip upgrade steps. (Calling from script with
       // DEFAULT_VERSION throws exception.)
       DCHECK(is_new_database);
-      pending_->callbacks->OnSuccess(
-          db_->CreateConnection(pending_->database_callbacks,
-                                pending_->child_process_id),
-          db_->metadata_);
+      pending_->OnSuccess(db_->CreateConnection(pending_->change_handler(),
+                                                pending_->child_process_id()),
+                          db_->metadata_);
       db_->RequestComplete(this);
       return;
     }
 
     if (!is_new_database &&
-        (new_version == old_version ||
-         new_version == IndexedDBDatabaseMetadata::NO_VERSION)) {
-      pending_->callbacks->OnSuccess(
-          db_->CreateConnection(pending_->database_callbacks,
-                                pending_->child_process_id),
-          db_->metadata_);
+        (pending_->version() == old_version ||
+         pending_->version() == IndexedDBDatabaseMetadata::NO_VERSION)) {
+      pending_->OnSuccess(db_->CreateConnection(pending_->change_handler(),
+                                                pending_->child_process_id()),
+                          db_->metadata_);
       db_->RequestComplete(this);
       return;
     }
 
-    if (new_version == IndexedDBDatabaseMetadata::NO_VERSION) {
+    if (pending_->version() == IndexedDBDatabaseMetadata::NO_VERSION) {
       // If no version is specified and no database exists, upgrade the
       // database version to 1.
       DCHECK(is_new_database);
-      new_version = 1;
-    } else if (new_version < old_version) {
+      pending_->set_version(1);
+    } else if (pending_->version() < old_version) {
       // Requested version is lower than current version - fail the request.
       DCHECK(!is_new_database);
-      pending_->callbacks->OnError(IndexedDBDatabaseError(
+      pending_->OnError(IndexedDBDatabaseError(
           blink::WebIDBDatabaseExceptionVersionError,
           ASCIIToUTF16("The requested version (") +
-              Int64ToString16(pending_->version) +
+              Int64ToString16(pending_->version()) +
               ASCIIToUTF16(") is less than the existing version (") +
               Int64ToString16(db_->metadata_.version) + ASCIIToUTF16(").")));
       db_->RequestComplete(this);
       return;
     }
 
     // Requested version is higher than current version - upgrade needed.
-    DCHECK_GT(new_version, old_version);
+    DCHECK_GT(pending_->version(), old_version);
 
     if (db_->connections_.empty()) {
       StartUpgrade();
       return;
     }
 
     // There are outstanding connections - fire "versionchange" events and
     // wait for the connections to close. Front end ensures the event is not
     // fired at connections that have close_pending set. A "blocked" event
     // will be fired at the request when one of the connections acks that the
     // "versionchange" event was ignored.
-    DCHECK_NE(pending_->data_loss_info.status, blink::WebIDBDataLossTotal);
+    DCHECK_NE(pending_->data_loss_info().status, blink::WebIDBDataLossTotal);
     for (const auto* connection : db_->connections_)
-      connection->callbacks()->OnVersionChange(old_version, new_version);
+      connection->change_handler()->OnVersionChange(old_version,
+                                                    pending_->version());
 
     // When all connections have closed the upgrade can proceed.
   }
 
   void OnVersionChangeIgnored() const override {
-    pending_->callbacks->OnBlocked(db_->metadata_.version);
+    pending_->OnBlocked(db_->metadata_.version);
   }
 
   void OnConnectionClosed(IndexedDBConnection* connection) override {
     // This connection closed prematurely; signal an error and complete.
-    if (connection && connection->callbacks() == pending_->database_callbacks) {
-      pending_->callbacks->OnError(
+    if (connection &&
+        connection->change_handler() == pending_->change_handler()) {
+      pending_->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionAbortError,
                                  "The connection was closed."));
       db_->RequestComplete(this);
       return;
     }
 
     if (!db_->connections_.empty())
       return;
 
     StartUpgrade();
   }
 
   // Initiate the upgrade. The bulk of the work actually happens in
   // IndexedDBDatabase::VersionChangeOperation in order to kick the
   // transaction into the correct state.
   void StartUpgrade() {
-    connection_ = db_->CreateConnection(pending_->database_callbacks,
-                                        pending_->child_process_id);
+    connection_ = db_->CreateConnection(pending_->change_handler(),
+                                        pending_->child_process_id());
     DCHECK_EQ(db_->connections_.count(connection_.get()), 1UL);
 
     std::vector<int64_t> object_store_ids;
     IndexedDBTransaction* transaction = db_->CreateTransaction(
-        pending_->transaction_id, connection_.get(), object_store_ids,
+        pending_->transaction_id(), connection_.get(), object_store_ids,
         blink::WebIDBTransactionModeVersionChange);
 
     DCHECK(db_->transaction_coordinator_.IsRunningVersionChangeTransaction());
     transaction->ScheduleTask(
         base::Bind(&IndexedDBDatabase::VersionChangeOperation, db_,
-                   pending_->version, pending_->callbacks));
+                   base::Unretained(pending_.get())));
   }
 
   // Called when the upgrade transaction has started executing.
   void UpgradeTransactionStarted(int64_t old_version) override {
     DCHECK(connection_);
-    pending_->callbacks->OnUpgradeNeeded(old_version, std::move(connection_),
-                                         db_->metadata_,
-                                         pending_->data_loss_info);
+    pending_->OnUpgradeNeeded(old_version, connection_.get(), db_->metadata_);
   }
 
   void UpgradeTransactionFinished(bool committed) override {
     // Ownership of connection was already passed along in OnUpgradeNeeded.
-    DCHECK(!connection_);
+    // Pending connection no longer moved in UpgradeTransactionStarted().
+    // DCHECK(!connection_);
 
     if (committed) {
-      DCHECK_EQ(pending_->version, db_->metadata_.version);
-      pending_->callbacks->OnSuccess(std::unique_ptr<IndexedDBConnection>(),
-                                     db_->metadata());
+      DCHECK_EQ(pending_->version(), db_->metadata_.version);
+      // TODO(cmumford): May still need to call RegisterTransactionId() because
+      //                 onupgradeneeded might not have been called.
+      pending_->OnSuccess(std::move(connection_), db_->metadata());
     } else {
-      DCHECK_NE(pending_->version, db_->metadata_.version);
-      pending_->callbacks->OnError(
+      DCHECK_NE(pending_->version(), db_->metadata_.version);
+      pending_->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionAbortError,
                                  "Version change transaction was aborted in "
                                  "upgradeneeded event handler."));
     }
     db_->RequestComplete(this);
   }
 
  private:
   std::unique_ptr<IndexedDBPendingConnection> pending_;
 
   // If an upgrade is needed, holds the pending connection until ownership is
   // transferred to the IndexedDBDispatcherHost via OnUpgradeNeeded.
   std::unique_ptr<IndexedDBConnection> connection_;
 
   DISALLOW_COPY_AND_ASSIGN(OpenRequest);
 };
 
 class IndexedDBDatabase::DeleteRequest
     : public IndexedDBDatabase::ConnectionRequest {
  public:
   DeleteRequest(scoped_refptr<IndexedDBDatabase> db,
-                scoped_refptr<IndexedDBCallbacks> callbacks)
-      : ConnectionRequest(db), callbacks_(callbacks) {}
+                std::unique_ptr<IndexedDBPendingDelete> pending_delete)
+      : ConnectionRequest(db), pending_delete_(std::move(pending_delete)) {}
 
   void Perform() override {
     if (db_->connections_.empty()) {
       // No connections, so delete immediately.
       DoDelete();
       return;
     }
 
     // Front end ensures the event is not fired at connections that have
     // close_pending set.
     const int64_t old_version = db_->metadata_.version;
     const int64_t new_version = IndexedDBDatabaseMetadata::NO_VERSION;
     for (const auto* connection : db_->connections_)
-      connection->callbacks()->OnVersionChange(old_version, new_version);
+      connection->change_handler()->OnVersionChange(old_version, new_version);
   }
 
   void OnVersionChangeIgnored() const override {
-    callbacks_->OnBlocked(db_->metadata_.version);
+    pending_delete_->OnBlocked(db_->metadata_.version);
   }
 
   void OnConnectionClosed(IndexedDBConnection* connection) override {
     if (!db_->connections_.empty())
       return;
     DoDelete();
   }
 
   void DoDelete() {
     leveldb::Status s =
         db_->backing_store_->DeleteDatabase(db_->metadata_.name);
     if (!s.ok()) {
       // TODO(jsbell): Consider including sanitized leveldb status message.
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error deleting database.");
-      callbacks_->OnError(error);
+      pending_delete_->OnError(error);
       if (s.IsCorruption()) {
         url::Origin origin = db_->backing_store_->origin();
         db_->backing_store_ = nullptr;
         db_->factory_->HandleBackingStoreCorruption(origin, error);
       }
       db_->RequestComplete(this);
       return;
     }
 
     int64_t old_version = db_->metadata_.version;
     db_->metadata_.id = kInvalidId;
     db_->metadata_.version = IndexedDBDatabaseMetadata::NO_VERSION;
     db_->metadata_.max_object_store_id = kInvalidId;
     db_->metadata_.object_stores.clear();
-    callbacks_->OnSuccess(old_version);
+    pending_delete_->OnSuccess(old_version);
     db_->factory_->DatabaseDeleted(db_->identifier_);
 
     db_->RequestComplete(this);
   }
 
   void UpgradeTransactionStarted(int64_t old_version) override { NOTREACHED(); }
 
   void UpgradeTransactionFinished(bool committed) override { NOTREACHED(); }
 
  private:
-  scoped_refptr<IndexedDBCallbacks> callbacks_;
+  std::unique_ptr<IndexedDBPendingDelete> pending_delete_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteRequest);
 };
 
 scoped_refptr<IndexedDBDatabase> IndexedDBDatabase::Create(
     const base::string16& name,
     IndexedDBBackingStore* backing_store,
     IndexedDBFactory* factory,
     const Identifier& unique_identifier,
     leveldb::Status* s) {
@@ skipping 90 matching lines @@
   DCHECK(transactions_.empty());
   DCHECK(!active_request_);
   DCHECK(pending_requests_.empty());
 }
 
 size_t IndexedDBDatabase::GetMaxMessageSizeInBytes() const {
   return kMaxIDBMessageSizeInBytes;
 }
 
 std::unique_ptr<IndexedDBConnection> IndexedDBDatabase::CreateConnection(
-    scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+    scoped_refptr<IndexedDBChangeHandler> change_handler,
     int child_process_id) {
   std::unique_ptr<IndexedDBConnection> connection(
-      base::MakeUnique<IndexedDBConnection>(this, database_callbacks));
+      base::MakeUnique<IndexedDBConnection>(this, change_handler));
   connections_.insert(connection.get());
   backing_store_->GrantChildProcessPermissions(child_process_id);
   return connection;
 }
 
 IndexedDBTransaction* IndexedDBDatabase::GetTransaction(
     int64_t transaction_id) const {
   const auto& trans_iterator = transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return NULL;
@@ skipping 332 matching lines @@
                                                     observer->id());
     }
   }
 }
 
 void IndexedDBDatabase::SendObservations(
     std::map<int32_t, std::unique_ptr<IndexedDBObserverChanges>> changes_map) {
   for (auto* conn : connections_) {
     auto it = changes_map.find(conn->id());
     if (it != changes_map.end())
-      conn->callbacks()->OnDatabaseChange(it->first, std::move(it->second));
+      conn->change_handler()->OnDatabaseChange(it->first,
+                                               std::move(it->second));
   }
 }
 
 void IndexedDBDatabase::GetAll(int64_t transaction_id,
                                int64_t object_store_id,
                                int64_t index_id,
                                std::unique_ptr<IndexedDBKeyRange> key_range,
                                bool key_only,
-                               int64_t max_count,
-                               scoped_refptr<IndexedDBCallbacks> callbacks) {
+                               int64_t max_count) {
   IDB_TRACE1("IndexedDBDatabase::GetAll", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::GetAllOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
-      max_count, callbacks));
+      max_count));
 }
 
 void IndexedDBDatabase::Get(int64_t transaction_id,
                             int64_t object_store_id,
                             int64_t index_id,
                             std::unique_ptr<IndexedDBKeyRange> key_range,
-                            bool key_only,
-                            scoped_refptr<IndexedDBCallbacks> callbacks) {
+                            bool key_only) {
   IDB_TRACE1("IndexedDBDatabase::Get", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::GetOperation, this, object_store_id, index_id,
-      base::Passed(&key_range),
-      key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
-      callbacks));
+      base::Passed(&key_range), key_only ? indexed_db::CURSOR_KEY_ONLY
+                                         : indexed_db::CURSOR_KEY_AND_VALUE));
 }
 
 void IndexedDBDatabase::GetOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     indexed_db::CursorType cursor_type,
-    scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::GetOperation", "txn.id", transaction->id());
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
 
   const IndexedDBKey* key;
 
@@ skipping 37 matching lines @@
     if (!s.ok()) {
       DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error deleting data in range");
       if (s.IsCorruption()) {
         factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       }
     }
 
     if (!backing_store_cursor) {
+#ifdef CJM_NEED_CALLBACK
       callbacks->OnSuccess();
+#endif
       return;
     }
 
     key = &backing_store_cursor->key();
   }
 
   std::unique_ptr<IndexedDBKey> primary_key;
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     // Object Store Retrieval Operation
     IndexedDBReturnValue value;
     s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                   id(),
                                   object_store_id,
                                   *key,
                                   &value);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error in GetRecord.");
+#ifdef CJM_NEED_CALLBACK
       callbacks->OnError(error);
+#endif
 
       if (s.IsCorruption())
         factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
 
     if (value.empty()) {
+#ifdef CJM_NEED_CALLBACK
       callbacks->OnSuccess();
+#endif
       return;
     }
 
     if (object_store_metadata.auto_increment &&
         !object_store_metadata.key_path.IsNull()) {
       value.primary_key = *key;
       value.key_path = object_store_metadata.key_path;
     }
 
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnSuccess(&value);
+#endif
     return;
   }
 
   // From here we are dealing only with indexes.
   s = backing_store_->GetPrimaryKeyViaIndex(
       transaction->BackingStoreTransaction(),
       id(),
       object_store_id,
       index_id,
       *key,
       &primary_key);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetPrimaryKeyViaIndex.");
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnError(error);
+#endif
     if (s.IsCorruption())
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
   if (!primary_key) {
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnSuccess();
+#endif
     return;
   }
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // Index Value Retrieval Operation
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnSuccess(*primary_key);
+#endif
     return;
   }
 
   // Index Referenced Value Retrieval Operation
   IndexedDBReturnValue value;
   s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                 id(),
                                 object_store_id,
                                 *primary_key,
                                 &value);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetRecord.");
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnError(error);
+#endif
     if (s.IsCorruption())
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
 
   if (value.empty()) {
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnSuccess();
+#endif
     return;
   }
   if (object_store_metadata.auto_increment &&
       !object_store_metadata.key_path.IsNull()) {
     value.primary_key = *primary_key;
     value.key_path = object_store_metadata.key_path;
   }
+#ifdef CJM_NEED_CALLBACK
   callbacks->OnSuccess(&value);
+#endif
 }
 
 void IndexedDBDatabase::GetAllOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     indexed_db::CursorType cursor_type,
     int64_t max_count,
-    scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::GetAllOperation", "txn.id", transaction->id());
 
   DCHECK_GT(max_count, 0);
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
 
@@ skipping 26 matching lines @@
       cursor = backing_store_->OpenIndexCursor(
           transaction->BackingStoreTransaction(), id(), object_store_id,
           index_id, *key_range, blink::WebIDBCursorDirectionNext, &s);
     }
   }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetAllOperation");
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnError(error);
+#endif
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
 
   std::vector<IndexedDBKey> found_keys;
   std::vector<IndexedDBReturnValue> found_values;
   if (!cursor) {
     // Doesn't matter if key or value array here - will be empty array when it
     // hits JavaScript.
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnSuccessArray(&found_values, object_store_metadata.key_path);
+#endif
     return;
   }
 
   bool did_first_seek = false;
   bool generated_key = object_store_metadata.auto_increment &&
                        !object_store_metadata.key_path.IsNull();
 
   size_t response_size = kMaxIDBMessageOverhead;
   int64_t num_found_items = 0;
   while (num_found_items++ < max_count) {
     bool cursor_valid;
     if (did_first_seek) {
       cursor_valid = cursor->Continue(&s);
     } else {
       cursor_valid = cursor->FirstSeek(&s);
       did_first_seek = true;
     }
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error in GetAllOperation.");
+#ifdef CJM_NEED_CALLBACK
       callbacks->OnError(error);
+#endif
       if (s.IsCorruption())
         factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
 
     if (!cursor_valid)
       break;
 
     IndexedDBReturnValue return_value;
     IndexedDBKey return_key;
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
       return_key = cursor->primary_key();
     } else {
       // Retrieving values
       return_value.swap(*cursor->value());
       if (!return_value.empty() && generated_key) {
         return_value.primary_key = cursor->primary_key();
         return_value.key_path = object_store_metadata.key_path;
       }
     }
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY)
       response_size += return_key.size_estimate();
     else
       response_size += return_value.SizeEstimate();
     if (response_size > GetMaxMessageSizeInBytes()) {
+#ifdef CJM_NEED_CALLBACK
       callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Maximum IPC message size exceeded."));
+#endif
       return;
     }
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY)
       found_keys.push_back(return_key);
     else
       found_values.push_back(return_value);
   }
 
+#ifdef CJM_NEED_CALLBACK
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // IndexedDBKey already supports an array of values so we can leverage  this
     // to return an array of keys - no need to create our own array of keys.
     callbacks->OnSuccess(IndexedDBKey(found_keys));
   } else {
     callbacks->OnSuccessArray(&found_values, object_store_metadata.key_path);
   }
+#endif
 }
 
 static std::unique_ptr<IndexedDBKey> GenerateKey(
     IndexedDBBackingStore* backing_store,
     IndexedDBTransaction* transaction,
     int64_t database_id,
     int64_t object_store_id) {
   const int64_t max_generator_value =
       9007199254740992LL;  // Maximum integer storable as ECMAScript number.
   int64_t current_number;
@@ skipping 24 matching lines @@
       static_cast<int64_t>(floor(key.number())) + 1, check_current);
 }
 
 struct IndexedDBDatabase::PutOperationParams {
   PutOperationParams() {}
   int64_t object_store_id;
   IndexedDBValue value;
   ScopedVector<storage::BlobDataHandle> handles;
   std::unique_ptr<IndexedDBKey> key;
   blink::WebIDBPutMode put_mode;
-  scoped_refptr<IndexedDBCallbacks> callbacks;
   std::vector<IndexKeys> index_keys;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PutOperationParams);
 };
 
 void IndexedDBDatabase::Put(int64_t transaction_id,
                             int64_t object_store_id,
                             IndexedDBValue* value,
                             ScopedVector<storage::BlobDataHandle>* handles,
                             std::unique_ptr<IndexedDBKey> key,
                             blink::WebIDBPutMode put_mode,
-                            scoped_refptr<IndexedDBCallbacks> callbacks,
                             const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE1("IndexedDBDatabase::Put", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   DCHECK(key);
   DCHECK(value);
   std::unique_ptr<PutOperationParams> params(
       base::MakeUnique<PutOperationParams>());
   params->object_store_id = object_store_id;
   params->value.swap(*value);
   params->handles.swap(*handles);
   params->key = std::move(key);
   params->put_mode = put_mode;
-  params->callbacks = callbacks;
   params->index_keys = index_keys;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::PutOperation, this, base::Passed(&params)));
 }
 
 void IndexedDBDatabase::PutOperation(std::unique_ptr<PutOperationParams> params,
                                      IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::PutOperation", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
   bool key_was_generated = false;
 
   DCHECK(metadata_.object_stores.find(params->object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store =
       metadata_.object_stores[params->object_store_id];
   DCHECK(object_store.auto_increment || params->key->IsValid());
 
   std::unique_ptr<IndexedDBKey> key;
   if (params->put_mode != blink::WebIDBPutModeCursorUpdate &&
       object_store.auto_increment && !params->key->IsValid()) {
     std::unique_ptr<IndexedDBKey> auto_inc_key = GenerateKey(
         backing_store_.get(), transaction, id(), params->object_store_id);
     key_was_generated = true;
     if (!auto_inc_key->IsValid()) {
+#ifdef CJM_NEED_CALLBACK
       params->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Maximum key generator value reached."));
+#endif
       return;
     }
     key = std::move(auto_inc_key);
   } else {
     key = std::move(params->key);
   }
 
   DCHECK(key->IsValid());
 
   IndexedDBBackingStore::RecordIdentifier record_identifier;
   if (params->put_mode == blink::WebIDBPutModeAddOnly) {
     bool found = false;
     leveldb::Status s = backing_store_->KeyExistsInObjectStore(
         transaction->BackingStoreTransaction(),
         id(),
         params->object_store_id,
         *key,
         &record_identifier,
         &found);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error checking key existence.");
+#ifdef CJM_NEED_CALLBACK
       params->callbacks->OnError(error);
+#endif
       if (s.IsCorruption())
         factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
     if (found) {
+#ifdef CJM_NEED_CALLBACK
       params->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Key already exists in the object store."));
+#endif
       return;
     }
   }
 
   ScopedVector<IndexWriter> index_writers;
   base::string16 error_message;
   bool obeys_constraints = false;
   bool backing_store_success = MakeIndexWriters(transaction,
                                                 backing_store_.get(),
                                                 id(),
                                                 object_store,
                                                 *key,
                                                 key_was_generated,
                                                 params->index_keys,
                                                 &index_writers,
                                                 &error_message,
                                                 &obeys_constraints);
   if (!backing_store_success) {
+#ifdef CJM_NEED_CALLBACK
     params->callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error updating index keys."));
+#endif
     return;
   }
   if (!obeys_constraints) {
+#ifdef CJM_NEED_CALLBACK
     params->callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionConstraintError, error_message));
+#endif
     return;
   }
 
   // Before this point, don't do any mutation. After this point, rollback the
   // transaction in case of error.
   leveldb::Status s =
       backing_store_->PutRecord(transaction->BackingStoreTransaction(),
                                 id(),
                                 params->object_store_id,
                                 *key,
                                 &params->value,
                                 &params->handles,
                                 &record_identifier);
   if (!s.ok()) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error performing put/add.");
+#ifdef CJM_NEED_CALLBACK
     params->callbacks->OnError(error);
+#endif
     if (s.IsCorruption())
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     return;
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.UpdateIndexes", "txn.id",
                transaction->id());
     for (size_t i = 0; i < index_writers.size(); ++i) {
       IndexWriter* index_writer = index_writers[i];
       index_writer->WriteIndexKeys(record_identifier, backing_store_.get(),
                                    transaction->BackingStoreTransaction(), id(),
                                    params->object_store_id);
     }
   }
 
   if (object_store.auto_increment &&
       params->put_mode != blink::WebIDBPutModeCursorUpdate &&
       key->type() == WebIDBKeyTypeNumber) {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.AutoIncrement", "txn.id",
                transaction->id());
     leveldb::Status s = UpdateKeyGenerator(backing_store_.get(),
                                            transaction,
                                            id(),
                                            params->object_store_id,
                                            *key,
                                            !key_was_generated);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error updating key generator.");
+#ifdef CJM_NEED_CALLBACK
       params->callbacks->OnError(error);
+#endif
       if (s.IsCorruption())
         factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.Callbacks", "txn.id",
                transaction->id());
+#ifdef CJM_NEED_CALLBACK
     params->callbacks->OnSuccess(*key);
+#endif
   }
   FilterObservation(transaction, params->object_store_id,
                     params->put_mode == blink::WebIDBPutModeAddOnly
                         ? blink::WebIDBAdd
                         : blink::WebIDBPut,
                     IndexedDBKeyRange(*key));
 }
 
 void IndexedDBDatabase::SetIndexKeys(int64_t transaction_id,
                                      int64_t object_store_id,
@@ skipping 93 matching lines @@
 }
 
 struct IndexedDBDatabase::OpenCursorOperationParams {
   OpenCursorOperationParams() {}
   int64_t object_store_id;
   int64_t index_id;
   std::unique_ptr<IndexedDBKeyRange> key_range;
   blink::WebIDBCursorDirection direction;
   indexed_db::CursorType cursor_type;
   blink::WebIDBTaskType task_type;
-  scoped_refptr<IndexedDBCallbacks> callbacks;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OpenCursorOperationParams);
 };
 
-void IndexedDBDatabase::OpenCursor(
-    int64_t transaction_id,
-    int64_t object_store_id,
-    int64_t index_id,
-    std::unique_ptr<IndexedDBKeyRange> key_range,
-    blink::WebIDBCursorDirection direction,
-    bool key_only,
-    blink::WebIDBTaskType task_type,
-    scoped_refptr<IndexedDBCallbacks> callbacks) {
+void IndexedDBDatabase::OpenCursor(int64_t transaction_id,
+                                   int64_t object_store_id,
+                                   int64_t index_id,
+                                   std::unique_ptr<IndexedDBKeyRange> key_range,
+                                   blink::WebIDBCursorDirection direction,
+                                   bool key_only,
+                                   blink::WebIDBTaskType task_type) {
   IDB_TRACE1("IndexedDBDatabase::OpenCursor", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   std::unique_ptr<OpenCursorOperationParams> params(
       base::MakeUnique<OpenCursorOperationParams>());
   params->object_store_id = object_store_id;
   params->index_id = index_id;
   params->key_range = std::move(key_range);
   params->direction = direction;
   params->cursor_type =
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE;
   params->task_type = task_type;
-  params->callbacks = callbacks;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::OpenCursorOperation, this, base::Passed(&params)));
 }
 
 void IndexedDBDatabase::OpenCursorOperation(
     std::unique_ptr<OpenCursorOperationParams> params,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::OpenCursorOperation", "txn.id", transaction->id());
 
@@ skipping 52 matching lines @@
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error opening cursor operation");
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
   }
 
   if (!backing_store_cursor) {
     // Why is Success being called?
+#ifdef CJM_NEED_CALLBACK
     params->callbacks->OnSuccess(nullptr);
+#endif
     return;
   }
 
+#ifdef CJM_NEED_CALLBACK
   scoped_refptr<IndexedDBCursor> cursor =
       new IndexedDBCursor(std::move(backing_store_cursor), params->cursor_type,
                           params->task_type, transaction);
   params->callbacks->OnSuccess(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
+#endif
 }
 
 void IndexedDBDatabase::Count(int64_t transaction_id,
                               int64_t object_store_id,
                               int64_t index_id,
-                              std::unique_ptr<IndexedDBKeyRange> key_range,
-                              scoped_refptr<IndexedDBCallbacks> callbacks) {
+                              std::unique_ptr<IndexedDBKeyRange> key_range) {
   IDB_TRACE1("IndexedDBDatabase::Count", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
-  transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::CountOperation,
-                                       this,
-                                       object_store_id,
-                                       index_id,
-                                       base::Passed(&key_range),
-                                       callbacks));
+  transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::CountOperation, this,
+                                       object_store_id, index_id,
+                                       base::Passed(&key_range)));
 }
 
 void IndexedDBDatabase::CountOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
-    scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::CountOperation", "txn.id", transaction->id());
   uint32_t count = 0;
   std::unique_ptr<IndexedDBBackingStore::Cursor> backing_store_cursor;
 
   leveldb::Status s;
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     backing_store_cursor = backing_store_->OpenObjectStoreKeyCursor(
         transaction->BackingStoreTransaction(),
         id(),
@@ skipping 13 matching lines @@
   }
   if (!s.ok()) {
     DLOG(ERROR) << "Unable perform count operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error performing count operation");
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
   }
   if (!backing_store_cursor) {
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnSuccess(count);
+#endif
     return;
   }
 
   do {
     ++count;
   } while (backing_store_cursor->Continue(&s));
 
   // TODO(cmumford): Check for database corruption.
 
+#ifdef CJM_NEED_CALLBACK
   callbacks->OnSuccess(count);
+#endif
 }
 
 void IndexedDBDatabase::DeleteRange(
     int64_t transaction_id,
     int64_t object_store_id,
-    std::unique_ptr<IndexedDBKeyRange> key_range,
-    scoped_refptr<IndexedDBCallbacks> callbacks) {
+    std::unique_ptr<IndexedDBKeyRange> key_range) {
   IDB_TRACE1("IndexedDBDatabase::DeleteRange", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::DeleteRangeOperation,
-                                       this,
-                                       object_store_id,
-                                       base::Passed(&key_range),
-                                       callbacks));
+                                       this, object_store_id,
+                                       base::Passed(&key_range)));
 }
 
 void IndexedDBDatabase::DeleteRangeOperation(
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
-    scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteRangeOperation", "txn.id",
              transaction->id());
   size_t delete_count = 0;
   leveldb::Status s =
       backing_store_->DeleteRange(transaction->BackingStoreTransaction(), id(),
                                   object_store_id, *key_range, &delete_count);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting data in range");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
+#ifdef CJM_NEED_CALLBACK
   if (experimental_web_platform_features_enabled_) {
     callbacks->OnSuccess(base::checked_cast<int64_t>(delete_count));
   } else {
     callbacks->OnSuccess();
   }
+#endif
   FilterObservation(transaction, object_store_id, blink::WebIDBDelete,
                     *key_range);
 }
 
-void IndexedDBDatabase::Clear(int64_t transaction_id,
-                              int64_t object_store_id,
-                              scoped_refptr<IndexedDBCallbacks> callbacks) {
+void IndexedDBDatabase::Clear(int64_t transaction_id, int64_t object_store_id) {
   IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
-  transaction->ScheduleTask(base::Bind(
-      &IndexedDBDatabase::ClearOperation, this, object_store_id, callbacks));
+  transaction->ScheduleTask(
+      base::Bind(&IndexedDBDatabase::ClearOperation, this, object_store_id));
 }
 
 void IndexedDBDatabase::ClearOperation(
     int64_t object_store_id,
-    scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::ClearOperation", "txn.id", transaction->id());
   leveldb::Status s = backing_store_->ClearObjectStore(
       transaction->BackingStoreTransaction(), id(), object_store_id);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error clearing object store");
+#ifdef CJM_NEED_CALLBACK
     callbacks->OnError(error);
+#endif
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
+#ifdef CJM_NEED_CALLBACK
   callbacks->OnSuccess();
+#endif
 
   FilterObservation(transaction, object_store_id, blink::WebIDBClear,
                     IndexedDBKeyRange());
 }
 
 void IndexedDBDatabase::DeleteObjectStoreOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
@@ skipping 18 matching lines @@
   }
 
   RemoveObjectStore(object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreAbortOperation,
                  this,
                  object_store_metadata));
 }
 
 void IndexedDBDatabase::VersionChangeOperation(
-    int64_t version,
-    scoped_refptr<IndexedDBCallbacks> callbacks,
+    const IndexedDBPendingConnection* pending_connection,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::VersionChangeOperation", "txn.id", transaction->id());
   int64_t old_version = metadata_.version;
-  DCHECK_GT(version, old_version);
+  DCHECK_GT(pending_connection->version(), old_version);
 
   if (!backing_store_->UpdateIDBDatabaseIntVersion(
-          transaction->BackingStoreTransaction(), id(), version)) {
+          transaction->BackingStoreTransaction(), id(),
+          pending_connection->version())) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16(
             "Internal error writing data to stable storage when "
             "updating version."));
-    callbacks->OnError(error);
+    pending_connection->OnError(error);
     transaction->Abort(error);
     return;
   }
 
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::VersionChangeAbortOperation, this,
                  metadata_.version));
-  metadata_.version = version;
+  metadata_.version = pending_connection->version();
 
   active_request_->UpgradeTransactionStarted(old_version);
 }
 
 void IndexedDBDatabase::TransactionFinished(IndexedDBTransaction* transaction,
                                             bool committed) {
   IDB_TRACE1("IndexedDBTransaction::TransactionFinished", "txn.id", id());
   DCHECK(transactions_.find(transaction->id()) != transactions_.end());
   DCHECK_EQ(transactions_[transaction->id()], transaction);
   transactions_.erase(transaction->id());
@@ skipping 81 matching lines @@
 void IndexedDBDatabase::TransactionCreated(IndexedDBTransaction* transaction) {
   transactions_[transaction->id()] = transaction;
 }
 
 void IndexedDBDatabase::OpenConnection(
     std::unique_ptr<IndexedDBPendingConnection> connection) {
   AppendRequest(base::MakeUnique<OpenRequest>(this, std::move(connection)));
 }
 
 void IndexedDBDatabase::DeleteDatabase(
-    scoped_refptr<IndexedDBCallbacks> callbacks) {
-  AppendRequest(base::MakeUnique<DeleteRequest>(this, callbacks));
+    std::unique_ptr<IndexedDBPendingDelete> pending_delete) {
+  AppendRequest(
+      base::MakeUnique<DeleteRequest>(this, std::move(pending_delete)));
 }
 
 void IndexedDBDatabase::ForceClose() {
   // IndexedDBConnection::ForceClose() may delete this database, so hold ref.
   scoped_refptr<IndexedDBDatabase> protect(this);
   auto it = connections_.begin();
   while (it != connections_.end()) {
     IndexedDBConnection* connection = *it++;
     connection->ForceClose();
   }
@@ skipping 12 matching lines @@
 
   IDB_TRACE("IndexedDBDatabase::Close");
 
   // Abort outstanding transactions from the closing connection. This can not
   // happen if the close is requested by the connection itself as the
   // front-end defers the close until all transactions are complete, but can
   // occur on process termination or forced close.
   {
     auto transactions(transactions_);
     for (const auto& it : transactions) {
-      if (it.second->callbacks() == connection->callbacks())
+      if (it.second->change_handler() == connection->change_handler())
         it.second->Abort(
             IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Connection is closing."));
     }
   }
 
   // Abort transactions before removing the connection; aborting may complete
   // an upgrade, and thus allow the next open/delete requests to proceed. The
   // new active_request_ should see the old connection count until explicitly
   // notified below.
@@ skipping 32 matching lines @@
 }
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
+IndexedDBContext* IndexedDBDatabase::context() const {
+  return factory_->context();
+}
+
 }  // namespace content