IndexedDB: Saving data loss status in IndexedDBPendingConnection.

content/browser/indexed_db/indexed_db_factory_unittest.cc

 // Copyright 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 <stdint.h>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
@@ skipping 235 matching lines @@
   const Origin origin(GURL("http://localhost:81"));
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<DiskFullFactory> factory = new DiskFullFactory(context());
   scoped_refptr<LookingForQuotaErrorMockCallbacks> callbacks =
       new LookingForQuotaErrorMockCallbacks;
   scoped_refptr<IndexedDBDatabaseCallbacks> dummy_database_callbacks =
       new IndexedDBDatabaseCallbacks(NULL, 0, 0);
   const base::string16 name(ASCIIToUTF16("name"));
-  IndexedDBPendingConnection connection(callbacks,
-                                        dummy_database_callbacks,
-                                        0, /* child_process_id */
-                                        2, /* transaction_id */
-                                        1 /* version */);
-  factory->Open(name, connection, NULL /* request_context */, origin,
+  std::unique_ptr<IndexedDBPendingConnection> connection(
+      new IndexedDBPendingConnection(callbacks, dummy_database_callbacks,
+                                     0, /* child_process_id */
+                                     2, /* transaction_id */
+                                     1 /* version */));
+  factory->Open(name, std::move(connection), NULL /* request_context */, origin,
                 temp_directory.path());
   EXPECT_TRUE(callbacks->error_called());
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreReleasedOnForcedClose) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64_t transaction_id = 1;
-  IndexedDBPendingConnection connection(
-      callbacks, db_callbacks, 0, /* child_process_id */
-      transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION);
-  factory()->Open(ASCIIToUTF16("db"), connection, NULL /* request_context */,
-                  origin, temp_directory.path());
+  std::unique_ptr<IndexedDBPendingConnection> connection(
+      new IndexedDBPendingConnection(
+          callbacks, db_callbacks, 0, /* child_process_id */
+          transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION));
+  factory()->Open(ASCIIToUTF16("db"), std::move(connection),
+                  NULL /* request_context */, origin, temp_directory.path());
 
   EXPECT_TRUE(callbacks->connection());
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 
   callbacks->connection()->ForceClose();
 
   EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreReleaseDelayedOnClose) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64_t transaction_id = 1;
-  IndexedDBPendingConnection connection(
-      callbacks, db_callbacks, 0, /* child_process_id */
-      transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION);
-  factory()->Open(ASCIIToUTF16("db"), connection, NULL /* request_context */,
-                  origin, temp_directory.path());
+  std::unique_ptr<IndexedDBPendingConnection> connection(
+      new IndexedDBPendingConnection(
+          callbacks, db_callbacks, 0, /* child_process_id */
+          transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION));
+  factory()->Open(ASCIIToUTF16("db"), std::move(connection),
+                  NULL /* request_context */, origin, temp_directory.path());
 
   EXPECT_TRUE(callbacks->connection());
   IndexedDBBackingStore* store =
       callbacks->connection()->database()->backing_store();
   EXPECT_FALSE(store->HasOneRef());  // Factory and database.
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   callbacks->connection()->Close();
   EXPECT_TRUE(store->HasOneRef());  // Factory.
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
@@ skipping 61 matching lines @@
 TEST_F(IndexedDBFactoryTest, ForceCloseReleasesBackingStore) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64_t transaction_id = 1;
-  IndexedDBPendingConnection connection(
-      callbacks, db_callbacks, 0, /* child_process_id */
-      transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION);
-  factory()->Open(ASCIIToUTF16("db"), connection, NULL /* request_context */,
-                  origin, temp_directory.path());
+  std::unique_ptr<IndexedDBPendingConnection> connection(
+      new IndexedDBPendingConnection(
+          callbacks, db_callbacks, 0, /* child_process_id */
+          transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION));
+  factory()->Open(ASCIIToUTF16("db"), std::move(connection),
+                  NULL /* request_context */, origin, temp_directory.path());
 
   EXPECT_TRUE(callbacks->connection());
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 
   callbacks->connection()->Close();
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_TRUE(factory()->IsBackingStorePendingClose(origin));
 
   factory()->ForceClose(origin);
 
   EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 
   // Ensure it is safe if the store is not open.
   factory()->ForceClose(origin);
 }
 
 class UpgradeNeededCallbacks : public MockIndexedDBCallbacks {
  public:
   UpgradeNeededCallbacks() {}
 
   void OnSuccess(std::unique_ptr<IndexedDBConnection> connection,
                  const IndexedDBDatabaseMetadata& metadata) override {
     EXPECT_TRUE(connection_.get());
     EXPECT_FALSE(connection.get());
   }
 
-  void OnUpgradeNeeded(
-      int64_t old_version,
-      std::unique_ptr<IndexedDBConnection> connection,
-      const content::IndexedDBDatabaseMetadata& metadata) override {
+  void OnUpgradeNeeded(int64_t old_version,
+                       std::unique_ptr<IndexedDBConnection> connection,
+                       const content::IndexedDBDatabaseMetadata& metadata,
+                       const IndexedDBDataLossInfo& data_loss_info) override {
     connection_ = std::move(connection);
   }
 
  protected:
   ~UpgradeNeededCallbacks() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UpgradeNeededCallbacks);
 };
 
@@ skipping 22 matching lines @@
   const base::string16 db_name(ASCIIToUTF16("db"));
   const int64_t db_version = 2;
   const int64_t transaction_id = 1;
   scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
 
   // Open at version 2, then close.
   {
     scoped_refptr<MockIndexedDBCallbacks> callbacks(
         new UpgradeNeededCallbacks());
-    IndexedDBPendingConnection connection(callbacks,
-                                          db_callbacks,
-                                          0, /* child_process_id */
-                                          transaction_id,
-                                          db_version);
-    factory()->Open(db_name, connection, NULL /* request_context */, origin,
-                    temp_directory.path());
+    std::unique_ptr<IndexedDBPendingConnection> connection(
+        new IndexedDBPendingConnection(callbacks, db_callbacks,
+                                       0, /* child_process_id */
+                                       transaction_id, db_version));
+    factory()->Open(db_name, std::move(connection), NULL /* request_context */,
+                    origin, temp_directory.path());
     EXPECT_TRUE(factory()->IsDatabaseOpen(origin, db_name));
 
     // Pump the message loop so the upgrade transaction can run.
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(callbacks->connection());
     callbacks->connection()->database()->Commit(transaction_id);
 
     callbacks->connection()->Close();
     EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
   }
 
   // Open at version < 2, which will fail; ensure factory doesn't retain
   // the database object.
   {
     scoped_refptr<ErrorCallbacks> callbacks(new ErrorCallbacks());
-    IndexedDBPendingConnection connection(callbacks,
-                                          db_callbacks,
-                                          0, /* child_process_id */
-                                          transaction_id,
-                                          db_version - 1);
-    factory()->Open(db_name, connection, NULL /* request_context */, origin,
-                    temp_directory.path());
+    std::unique_ptr<IndexedDBPendingConnection> connection(
+        new IndexedDBPendingConnection(callbacks, db_callbacks,
+                                       0, /* child_process_id */
+                                       transaction_id, db_version - 1));
+    factory()->Open(db_name, std::move(connection), NULL /* request_context */,
+                    origin, temp_directory.path());
     EXPECT_TRUE(callbacks->saw_error());
     EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
   }
 
   // Terminate all pending-close timers.
   factory()->ForceClose(origin);
 }
 
 }  // namespace content