Convert WebIDBDatabaseImpl to IndexedDBConnection

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"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
+#include "content/browser/indexed_db/indexed_db_connection.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_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
 
@@ skipping 26 matching lines @@
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const IndexedDBObjectStoreMetadata object_store_metadata_;
 };
 
 class IndexedDBDatabase::VersionChangeOperation
     : public IndexedDBTransaction::Operation {
  public:
-  VersionChangeOperation(
-      scoped_refptr<IndexedDBDatabase> database,
-      int64 transaction_id,
-      int64 version,
-      scoped_refptr<IndexedDBCallbacks> callbacks,
-      scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
-      WebKit::WebIDBCallbacks::DataLoss data_loss)
+  VersionChangeOperation(scoped_refptr<IndexedDBDatabase> database,
+                         int64 transaction_id,
+                         int64 version,
+                         scoped_refptr<IndexedDBCallbacks> callbacks,
+                         scoped_ptr<IndexedDBConnection> connection,
+                         WebKit::WebIDBCallbacks::DataLoss data_loss)
       : database_(database),
         transaction_id_(transaction_id),
         version_(version),
         callbacks_(callbacks),
-        database_callbacks_(database_callbacks),
+        connection_(connection.Pass()),
         data_loss_(data_loss) {}
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   scoped_refptr<IndexedDBDatabase> database_;
   int64 transaction_id_;
   int64 version_;
   scoped_refptr<IndexedDBCallbacks> callbacks_;
-  scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks_;
+  scoped_ptr<IndexedDBConnection> connection_;
   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 268 matching lines @@
         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<IndexedDBCallbacks> callbacks_;
 };
 
+// PendingOpenCall has a scoped_refptr<IndexedDBDatabaseCallbacks> because it
+// isn't a connection yet.
 class IndexedDBDatabase::PendingOpenCall {
  public:
   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<IndexedDBCallbacks> Callbacks() { return callbacks_; }
   scoped_refptr<IndexedDBDatabaseCallbacks> DatabaseCallbacks() {
     return database_callbacks_;
   }
   int64 Version() { return version_; }
   int64 TransactionId() const { return transaction_id_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks_;
   int64 version_;
   const int64 transaction_id_;
 };
 
+// PendingUpgradeCall has a scoped_ptr<IndexedDBConnection> because it owns the
+// in-progress connection.
+class IndexedDBDatabase::PendingUpgradeCall {
+ public:
+  PendingUpgradeCall(scoped_refptr<IndexedDBCallbacks> callbacks,
+                     scoped_ptr<IndexedDBConnection> connection,
+                     int64 transaction_id,
+                     int64 version)
+      : callbacks_(callbacks),
+        connection_(connection.Pass()),
+        version_(version),
+        transaction_id_(transaction_id) {}
+  scoped_refptr<IndexedDBCallbacks> Callbacks() { return callbacks_; }
+  scoped_ptr<IndexedDBConnection> Connection() { return connection_.Pass(); }
+  int64 Version() { return version_; }
+  int64 TransactionId() const { return transaction_id_; }
+
+ private:
+  scoped_refptr<IndexedDBCallbacks> callbacks_;
+  scoped_ptr<IndexedDBConnection> connection_;
+  int64 version_;
+  const int64 transaction_id_;
+};
+
+// PendingSuccessCall has a IndexedDBConnection* because the connection is now
+// owned elsewhere, but we need to cancel the success call if that connection
+// closes before it is sent.
+class IndexedDBDatabase::PendingSuccessCall {
+ public:
+  PendingSuccessCall(scoped_refptr<IndexedDBCallbacks> callbacks,
+                     IndexedDBConnection* connection,
+                     int64 transaction_id,
+                     int64 version)
+      : callbacks_(callbacks),
+        connection_(connection),
+        version_(version),
+        transaction_id_(transaction_id) {}
+  scoped_refptr<IndexedDBCallbacks> Callbacks() { return callbacks_; }
+  IndexedDBConnection* Connection() { return connection_; }
+  int64 Version() { return version_; }
+  int64 TransactionId() const { return transaction_id_; }
+
+ private:
+  scoped_refptr<IndexedDBCallbacks> callbacks_;
+  IndexedDBConnection* connection_;
+  int64 version_;
+  const int64 transaction_id_;
+};
+
 class IndexedDBDatabase::PendingDeleteCall {
  public:
   explicit PendingDeleteCall(scoped_refptr<IndexedDBCallbacks> callbacks)
       : callbacks_(callbacks) {}
   scoped_refptr<IndexedDBCallbacks> Callbacks() { return callbacks_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
@@ skipping 977 matching lines @@
           database_->metadata_.int_version)) {
     IndexedDBDatabaseError error(
         WebKit::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error writing data to stable storage when "
                      "updating version."));
     callbacks_->OnError(error);
     transaction->Abort(error);
     return;
   }
   DCHECK(!database_->pending_second_half_open_);
-  database_->pending_second_half_open_.reset(new PendingOpenCall(
-      callbacks_, database_callbacks_, transaction_id_, version_));
+
+  database_->pending_second_half_open_.reset(new PendingSuccessCall(
+      callbacks_, connection_.get(), transaction_id_, version_));
   callbacks_->OnUpgradeNeeded(
-      old_version, database_, database_->metadata(), data_loss_);
+      old_version, connection_.Pass(), database_->metadata(), data_loss_);
 }
 
 void IndexedDBDatabase::TransactionStarted(IndexedDBTransaction* transaction) {
 
   if (transaction->mode() == indexed_db::TRANSACTION_VERSION_CHANGE) {
     DCHECK(!running_version_change_transaction_);
     running_version_change_transaction_ = transaction;
   }
 }
 
@@ skipping 22 matching lines @@
   }
 }
 
 void IndexedDBDatabase::TransactionFinishedAndCompleteFired(
     IndexedDBTransaction* transaction) {
   if (transaction->mode() == indexed_db::TRANSACTION_VERSION_CHANGE) {
     DCHECK(pending_second_half_open_);
     if (pending_second_half_open_) {
       DCHECK_EQ(pending_second_half_open_->Version(), metadata_.int_version);
       DCHECK(metadata_.id != kInvalidId);
-      pending_second_half_open_->Callbacks()->OnSuccess(this, this->metadata());
+
+      // Connection was already minted for OnUpgradeNeeded callback.
+      scoped_ptr<IndexedDBConnection> connection;
+
+      pending_second_half_open_->Callbacks()->OnSuccess(
+          connection.Pass(), this->metadata());
       pending_second_half_open_.reset();
     }
     ProcessPendingCalls();
   }
 }
 
 size_t IndexedDBDatabase::ConnectionCount() const {
   // This does not include pending open calls, as those should not block version
   // changes and deletes.
-  return database_callbacks_set_.size();
+  return connections_.size();
 }
 
 void IndexedDBDatabase::ProcessPendingCalls() {
-  if (pending_second_half_open_) {
-    DCHECK_EQ(pending_second_half_open_->Version(), metadata_.int_version);
-    DCHECK(metadata_.id != kInvalidId);
-    scoped_ptr<PendingOpenCall> pending_call = pending_second_half_open_.Pass();
-    pending_call->Callbacks()->OnSuccess(this, this->metadata());
-    // Fall through when complete, as pending opens may be unblocked.
-  }
-
   if (pending_run_version_change_transaction_call_ && ConnectionCount() == 1) {
     DCHECK(pending_run_version_change_transaction_call_->Version() >
            metadata_.int_version);
-    scoped_ptr<PendingOpenCall> pending_call =
+    scoped_ptr<PendingUpgradeCall> pending_call =
         pending_run_version_change_transaction_call_.Pass();
     RunVersionChangeTransactionFinal(pending_call->Callbacks(),
-                                     pending_call->DatabaseCallbacks(),
+                                     pending_call->Connection(),
                                      pending_call->TransactionId(),
                                      pending_call->Version());
     DCHECK_EQ(static_cast<size_t>(1), ConnectionCount());
     // Fall through would be a no-op, since transaction must complete
     // asynchronously.
     DCHECK(IsDeleteDatabaseBlocked());
     DCHECK(IsOpenConnectionBlocked());
     return;
   }
 
@@ skipping 22 matching lines @@
       OpenConnection(pending_open_call->Callbacks(),
                      pending_open_call->DatabaseCallbacks(),
                      pending_open_call->TransactionId(),
                      pending_open_call->Version());
     }
   }
 }
 
 void IndexedDBDatabase::CreateTransaction(
     int64 transaction_id,
-    scoped_refptr<IndexedDBDatabaseCallbacks> callbacks,
+    IndexedDBConnection* connection,
     const std::vector<int64>& object_store_ids,
     uint16 mode) {
 
-  DCHECK(database_callbacks_set_.has(callbacks));
+  DCHECK(connections_.has(connection));
 
   scoped_refptr<IndexedDBTransaction> transaction =
       IndexedDBTransaction::Create(
           transaction_id,
-          callbacks,
+          connection->callbacks(),
           object_store_ids,
           static_cast<indexed_db::TransactionMode>(mode),
           this);
   DCHECK(transactions_.find(transaction_id) == transactions_.end());
   transactions_[transaction_id] = transaction.get();
 }
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
@@ skipping 28 matching lines @@
     DCHECK_NE(WebKit::WebIDBCallbacks::DataLossTotal, data_loss);
     pending_open_calls_.push_back(new PendingOpenCall(
         callbacks, database_callbacks, transaction_id, version));
     return;
   }
 
   if (metadata_.id == kInvalidId) {
     // The database was deleted then immediately re-opened; OpenInternal()
     // recreates it in the backing store.
     if (OpenInternal()) {
-      DCHECK_EQ(metadata_.int_version,
-                IndexedDBDatabaseMetadata::NO_INT_VERSION);
+      DCHECK_EQ(IndexedDBDatabaseMetadata::NO_INT_VERSION,
+                metadata_.int_version);
     } else {
       string16 message;
       if (version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
         message = ASCIIToUTF16(
             "Internal error opening database with no version specified.");
       else
         message =
             ASCIIToUTF16("Internal error opening database with version ") +
             Int64ToString16(version);
       callbacks->OnError(IndexedDBDatabaseError(
           WebKit::WebIDBDatabaseExceptionUnknownError, message));
       return;
     }
   }
 
   // We infer that the database didn't exist from its lack of either type of
   // version.
   bool is_new_database =
       metadata_.version == kNoStringVersion &&
       metadata_.int_version == IndexedDBDatabaseMetadata::NO_INT_VERSION;
 
+  scoped_ptr<IndexedDBConnection> connection(
+      new IndexedDBConnection(this, database_callbacks));
+
   if (version == IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION) {
     // For unit tests only - skip upgrade steps. Calling from script with
     // DEFAULT_INT_VERSION throws exception.
     // TODO(jsbell): DCHECK that not in unit tests.
     DCHECK(is_new_database);
-    database_callbacks_set_.insert(database_callbacks);
-    callbacks->OnSuccess(this, this->metadata());
+    connections_.insert(connection.get());
+    callbacks->OnSuccess(connection.Pass(), this->metadata());
     return;
   }
 
   if (version == IndexedDBDatabaseMetadata::NO_INT_VERSION) {
     if (!is_new_database) {
-      database_callbacks_set_.insert(database_callbacks);
-      callbacks->OnSuccess(this, this->metadata());
+      connections_.insert(connection.get());
+      callbacks->OnSuccess(connection.Pass(), this->metadata());
       return;
     }
     // Spec says: If no version is specified and no database exists, set
     // database version to 1.
     version = 1;
   }
 
   if (version > metadata_.int_version) {
-    database_callbacks_set_.insert(database_callbacks);
+    connections_.insert(connection.get());
     RunVersionChangeTransaction(
-        callbacks, database_callbacks, transaction_id, version, data_loss);
+        callbacks, connection.Pass(), transaction_id, version, data_loss);
     return;
   }
   if (version < metadata_.int_version) {
     callbacks->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionVersionError,
         ASCIIToUTF16("The requested version (") + Int64ToString16(version) +
             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());
+  connections_.insert(connection.get());
+  callbacks->OnSuccess(connection.Pass(), this->metadata());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacks> callbacks,
-    scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+    scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version,
     WebKit::WebIDBCallbacks::DataLoss data_loss) {
 
   DCHECK(callbacks.get());
-  DCHECK(database_callbacks_set_.has(database_callbacks));
+  DCHECK(connections_.has(connection.get()));
   if (ConnectionCount() > 1) {
     DCHECK_NE(WebKit::WebIDBCallbacks::DataLossTotal, data_loss);
     // Front end ensures the event is not fired at connections that have
     // close_pending set.
-    for (DatabaseCallbacksSet::const_iterator it =
-             database_callbacks_set_.begin();
-         it != database_callbacks_set_.end();
+    for (ConnectionSet::const_iterator it = connections_.begin();
+         it != connections_.end();
          ++it) {
-      if (it->get() != database_callbacks.get())
-        (*it)->OnVersionChange(metadata_.int_version, requested_version);
+      if (*it != connection.get()) {
+        (*it)->callbacks()->OnVersionChange(
+            metadata_.int_version, requested_version);
+      }
     }
     // TODO(jsbell): Remove the call to OnBlocked and instead wait
     // until the frontend tells us that all the "versionchange" events
     // have been delivered.  http://crbug.com/100123
     callbacks->OnBlocked(metadata_.int_version);
 
     DCHECK(!pending_run_version_change_transaction_call_);
-    pending_run_version_change_transaction_call_.reset(new PendingOpenCall(
-        callbacks, database_callbacks, transaction_id, requested_version));
+    pending_run_version_change_transaction_call_.reset(new PendingUpgradeCall(
+        callbacks, connection.Pass(), transaction_id, requested_version));
     return;
   }
   RunVersionChangeTransactionFinal(callbacks,
-                                   database_callbacks,
+                                   connection.Pass(),
                                    transaction_id,
                                    requested_version,
                                    data_loss);
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks,
-    scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+    scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version) {
   const WebKit::WebIDBCallbacks::DataLoss kDataLoss =
       WebKit::WebIDBCallbacks::DataLossNone;
   RunVersionChangeTransactionFinal(callbacks,
-                                   database_callbacks,
+                                   connection.Pass(),
                                    transaction_id,
                                    requested_version,
                                    kDataLoss);
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks,
-    scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+    scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version,
     WebKit::WebIDBCallbacks::DataLoss data_loss) {
 
   std::vector<int64> object_store_ids;
   CreateTransaction(transaction_id,
-                    database_callbacks,
+                    connection.get(),
                     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,
+                                 connection.Pass(),
                                  data_loss),
       new VersionChangeAbortOperation(
           this, metadata_.version, metadata_.int_version));
 
   DCHECK(!pending_second_half_open_);
 }
 
 void IndexedDBDatabase::DeleteDatabase(
     scoped_refptr<IndexedDBCallbacks> callbacks) {
 
   if (IsDeleteDatabaseBlocked()) {
-    for (DatabaseCallbacksSet::const_iterator it =
-             database_callbacks_set_.begin();
-         it != database_callbacks_set_.end();
+    for (ConnectionSet::const_iterator it = connections_.begin();
+         it != connections_.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);
+      (*it)->callbacks()->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);
 }
@@ skipping 12 matching lines @@
                                "Internal error deleting database."));
     return;
   }
   metadata_.version = kNoStringVersion;
   metadata_.id = kInvalidId;
   metadata_.int_version = IndexedDBDatabaseMetadata::NO_INT_VERSION;
   metadata_.object_stores.clear();
   callbacks->OnSuccess();
 }
 
-void IndexedDBDatabase::Close(
-    scoped_refptr<IndexedDBDatabaseCallbacks> callbacks) {
-  DCHECK(callbacks.get());
-  DCHECK(database_callbacks_set_.has(callbacks));
+void IndexedDBDatabase::Close(IndexedDBConnection* connection) {
+  DCHECK(connections_.has(connection));
 
   // Close 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, so something unusual has happened e.g. unexpected
   // process termination.
   {
     TransactionMap transactions(transactions_);
     for (TransactionMap::const_iterator it = transactions.begin(),
                                         end = transactions.end();
          it != end;
          ++it) {
-      if (it->second->connection() == callbacks.get())
+      if (it->second->connection() == connection->callbacks())
         it->second->Abort(
             IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                    "Connection is closing."));
     }
   }
 
-  database_callbacks_set_.erase(callbacks);
+  connections_.erase(connection);
   if (pending_second_half_open_ &&
-      pending_second_half_open_->DatabaseCallbacks().get() == callbacks.get()) {
+      pending_second_half_open_->Connection() == connection) {
     pending_second_half_open_->Callbacks()->OnError(
         IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionAbortError,
                                "The connection was closed."));
     pending_second_half_open_.reset();
   }
 
   // process_pending_calls allows the inspector to process a pending open call
   // and call close, reentering IndexedDBDatabase::close. Then the
   // backend would be removed both by the inspector closing its connection, and
   // by the connection that first called close.
@@ skipping 34 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