Tell IDB frontend about data loss

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 46 matching lines @@
 };
 
 class IndexedDBDatabase::VersionChangeOperation
     : public IndexedDBTransaction::Operation {
  public:
   VersionChangeOperation(
       scoped_refptr<IndexedDBDatabase> database,
       int64 transaction_id,
       int64 version,
       scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
-      scoped_refptr<IndexedDBDatabaseCallbacksWrapper> database_callbacks)
+      scoped_refptr<IndexedDBDatabaseCallbacksWrapper> database_callbacks,
+      WebKit::WebIDBCallbacks::DataLoss data_loss)
       : database_(database),
         transaction_id_(transaction_id),
         version_(version),
         callbacks_(callbacks),
-        database_callbacks_(database_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<IndexedDBDatabaseCallbacksWrapper> 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;
 
  private:
@@ skipping 1296 matching lines @@
         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_));
-  callbacks_->OnUpgradeNeeded(old_version, database_, database_->metadata());
+  callbacks_->OnUpgradeNeeded(
+      old_version, database_, 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 121 matching lines @@
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
          pending_run_version_change_transaction_call_;
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacksWrapper> 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<IndexedDBDatabaseCallbacksWrapper> 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
+    // presence of existing connections means we didn't even check for data loss
+    // so there'd better not be any.
+    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,
@@ skipping 36 matching lines @@
       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);
     RunVersionChangeTransaction(
-        callbacks, database_callbacks, transaction_id, version);
+        callbacks, database_callbacks, 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());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacksWrapper> database_callbacks,
     int64 transaction_id,
-    int64 requested_version) {
+    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
     // close_pending set.
     for (DatabaseCallbacksSet::const_iterator it =
              database_callbacks_set_.begin();
          it != database_callbacks_set_.end();
          ++it) {
       if (it->get() != database_callbacks.get())
         (*it)->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));
     return;
   }
-  RunVersionChangeTransactionFinal(
-      callbacks, database_callbacks, transaction_id, requested_version);
+  RunVersionChangeTransactionFinal(callbacks,
+                                   database_callbacks,
+                                   transaction_id,
+                                   requested_version,
+                                   data_loss);
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
     scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacksWrapper> 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<IndexedDBDatabaseCallbacksWrapper> 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),
+                                 database_callbacks,
+                                 data_loss),
       new VersionChangeAbortOperation(
           this, metadata_.version, metadata_.int_version));
 
   DCHECK(!pending_second_half_open_);
 }
 
 void IndexedDBDatabase::DeleteDatabase(
     scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
 
   if (IsDeleteDatabaseBlocked()) {
@@ skipping 111 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