IndexedDB: Saving data loss status in IndexedDBPendingConnection.

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 99 matching lines @@
   scoped_refptr<IndexedDBDatabase> db_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OpenOrDeleteRequest);
 };
 
 class IndexedDBDatabase::OpenRequest
     : public IndexedDBDatabase::OpenOrDeleteRequest {
  public:
   OpenRequest(scoped_refptr<IndexedDBDatabase> db,
-              const IndexedDBPendingConnection& pending_connection)
-      : OpenOrDeleteRequest(db), pending_(pending_connection) {}
+              std::unique_ptr<IndexedDBPendingConnection> pending_connection)
+      : OpenOrDeleteRequest(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_->callbacks->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;
+    int64_t& new_version = pending_->version;
 
     bool is_new_database = old_version == IndexedDBDatabaseMetadata::NO_VERSION;
 
     if (new_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),
+      pending_->callbacks->OnSuccess(
+          db_->CreateConnection(pending_->database_callbacks,
+                                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),
+      pending_->callbacks->OnSuccess(
+          db_->CreateConnection(pending_->database_callbacks,
+                                pending_->child_process_id),
           db_->metadata_);
       db_->RequestComplete(this);
       return;
     }
 
     if (new_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) {
       // Requested version is lower than current version - fail the request.
       DCHECK(!is_new_database);
-      pending_.callbacks->OnError(IndexedDBDatabaseError(
+      pending_->callbacks->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);
 
     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_.callbacks->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);
 
     // When all connections have closed the upgrade can proceed.
   }
 
   void OnVersionChangeIgnored() const override {
-    pending_.callbacks->OnBlocked(db_->metadata_.version);
+    pending_->callbacks->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->callbacks() == pending_->database_callbacks) {
+      pending_->callbacks->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_->database_callbacks,
+                                        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));
+                   pending_->version, pending_->callbacks));
   }
 
   // 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_->callbacks->OnUpgradeNeeded(old_version, std::move(connection_),
+                                         db_->metadata_,
+                                         pending_->data_loss_info);
   }
 
   void UpgradeTransactionFinished(bool committed) override {
     // Ownership of connection was already passed along in OnUpgradeNeeded.
     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);
+      pending_->callbacks->OnSuccess(std::unique_ptr<IndexedDBConnection>(),
+                                     db_->metadata());
     } else {
-      DCHECK_NE(pending_.version, db_->metadata_.version);
-      pending_.callbacks->OnError(
+      DCHECK_NE(pending_->version, db_->metadata_.version);
+      pending_->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionAbortError,
                                  "Version change transaction was aborted in "
                                  "upgradeneeded event handler."));
     }
     db_->RequestComplete(this);
   }
 
  private:
-  IndexedDBPendingConnection pending_;
+  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::OpenOrDeleteRequest {
  public:
   DeleteRequest(scoped_refptr<IndexedDBDatabase> db,
                 scoped_refptr<IndexedDBCallbacks> callbacks)
       : OpenOrDeleteRequest(db), callbacks_(callbacks) {}
 
   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;
-    DCHECK_NE(callbacks_->data_loss_info().status, blink::WebIDBDataLossTotal);
     for (const auto* connection : db_->connections_)
       connection->callbacks()->OnVersionChange(old_version, new_version);
   }
 
   void OnVersionChangeIgnored() const override {
     callbacks_->OnBlocked(db_->metadata_.version);
   }
 
   void OnConnectionClosed(IndexedDBConnection* connection) override {
     if (!db_->connections_.empty())
@@ skipping 1595 matching lines @@
           mode, new IndexedDBBackingStore::Transaction(backing_store_.get()));
   TransactionCreated(transaction);
   return transaction;
 }
 
 void IndexedDBDatabase::TransactionCreated(IndexedDBTransaction* transaction) {
   transactions_[transaction->id()] = transaction;
 }
 
 void IndexedDBDatabase::OpenConnection(
-    const IndexedDBPendingConnection& connection) {
-  AppendRequest(base::MakeUnique<OpenRequest>(this, connection));
+    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));
 }
 
 void IndexedDBDatabase::ForceClose() {
   // IndexedDBConnection::ForceClose() may delete this database, so hold ref.
   scoped_refptr<IndexedDBDatabase> protect(this);
@@ skipping 71 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content