Delete and try to recreate localstorage database on invalid schema version.

components/leveldb/leveldb_service_unittest.cc

 // Copyright 2016 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 "base/bind.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "components/filesystem/public/interfaces/directory.mojom.h"
 #include "components/filesystem/public/interfaces/file_system.mojom.h"
 #include "components/filesystem/public/interfaces/types.mojom.h"
@@ skipping 77 matching lines @@
 void DatabaseSyncDeletePrefixed(mojom::LevelDBDatabase* database,
                                 const std::string& key_prefix,
                                 mojom::DatabaseError* out_error) {
   base::RunLoop run_loop;
   database->DeletePrefixed(StdStringToUint8Vector(key_prefix),
                            Capture(out_error, run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 void LevelDBSyncOpenInMemory(mojom::LevelDBService* leveldb,
-                             mojom::LevelDBDatabaseRequest database,
+                             mojom::LevelDBDatabaseAssociatedRequest database,
                              mojom::DatabaseError* out_error) {
   base::RunLoop run_loop;
   leveldb->OpenInMemory(std::move(database),
                         Capture(out_error, run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 class LevelDBServiceTest : public service_manager::test::ServiceTest {
  public:
   LevelDBServiceTest() : ServiceTest("leveldb_service_unittests") {}
@@ skipping 27 matching lines @@
 
  private:
   filesystem::mojom::FileSystemPtr files_;
   mojom::LevelDBServicePtr leveldb_;
 
   DISALLOW_COPY_AND_ASSIGN(LevelDBServiceTest);
 };
 
 TEST_F(LevelDBServiceTest, Basic) {
   mojom::DatabaseError error;
-  mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
+  mojom::LevelDBDatabaseAssociatedPtr database;
+  LevelDBSyncOpenInMemory(leveldb().get(),
+                          MakeRequest(&database, leveldb().associated_group()),
+                          &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Read the key back from the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   std::vector<uint8_t> value;
@@ skipping 12 matching lines @@
   // Read the key back from the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   value.clear();
   DatabaseSyncGet(database.get(), "key", &error, &value);
   EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error);
   EXPECT_EQ("", Uint8VectorToStdString(value));
 }
 
 TEST_F(LevelDBServiceTest, WriteBatch) {
   mojom::DatabaseError error;
-  mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
+  mojom::LevelDBDatabaseAssociatedPtr database;
+  LevelDBSyncOpenInMemory(leveldb().get(),
+                          MakeRequest(&database, leveldb().associated_group()),
+                          &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Create a batched operation which both deletes "key" and adds another write.
   std::vector<mojom::BatchedOperationPtr> operations;
   mojom::BatchedOperationPtr item = mojom::BatchedOperation::New();
   item->type = mojom::BatchOperationType::DELETE_KEY;
@@ skipping 60 matching lines @@
 TEST_F(LevelDBServiceTest, Reconnect) {
   mojom::DatabaseError error;
 
   filesystem::mojom::DirectoryPtr temp_directory;
   GetTempDirectory(&temp_directory);
 
   {
     filesystem::mojom::DirectoryPtr directory;
     temp_directory->Clone(MakeRequest(&directory));
 
-    mojom::LevelDBDatabasePtr database;
+    mojom::LevelDBDatabaseAssociatedPtr database;
     leveldb::mojom::OpenOptionsPtr options = leveldb::mojom::OpenOptions::New();
     options->error_if_exists = true;
     options->create_if_missing = true;
     base::RunLoop run_loop;
-    leveldb()->OpenWithOptions(std::move(options), std::move(directory), "test",
-                               MakeRequest(&database),
-                               Capture(&error, run_loop.QuitClosure()));
+    leveldb()->OpenWithOptions(
+        std::move(options), std::move(directory), "test",
+        MakeRequest(&database, leveldb().associated_group()),
+        Capture(&error, run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_EQ(mojom::DatabaseError::OK, error);
 
     // Write a key to the database.
     error = mojom::DatabaseError::INVALID_ARGUMENT;
     DatabaseSyncPut(database.get(), "key", "value", &error);
     EXPECT_EQ(mojom::DatabaseError::OK, error);
 
     // The database should go out of scope here.
   }
 
   {
     filesystem::mojom::DirectoryPtr directory;
     temp_directory->Clone(MakeRequest(&directory));
 
     // Reconnect to the database.
-    mojom::LevelDBDatabasePtr database;
+    mojom::LevelDBDatabaseAssociatedPtr database;
     base::RunLoop run_loop;
-    leveldb()->Open(std::move(directory), "test", MakeRequest(&database),
+    leveldb()->Open(std::move(directory), "test",
+                    MakeRequest(&database, leveldb().associated_group()),
                     Capture(&error, run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_EQ(mojom::DatabaseError::OK, error);
 
     // We should still be able to read the key back from the database.
     error = mojom::DatabaseError::INVALID_ARGUMENT;
     std::vector<uint8_t> value;
     DatabaseSyncGet(database.get(), "key", &error, &value);
     EXPECT_EQ(mojom::DatabaseError::OK, error);
     EXPECT_EQ("value", Uint8VectorToStdString(value));
   }
 }
 
+TEST_F(LevelDBServiceTest, Destroy) {
+  mojom::DatabaseError error;
+
+  filesystem::mojom::DirectoryPtr temp_directory;
+  GetTempDirectory(&temp_directory);
+
+  {
+    filesystem::mojom::DirectoryPtr directory;
+    temp_directory->Clone(MakeRequest(&directory));
+
+    mojom::LevelDBDatabaseAssociatedPtr database;
+    leveldb::mojom::OpenOptionsPtr options = leveldb::mojom::OpenOptions::New();
+    options->error_if_exists = true;
+    options->create_if_missing = true;
+    base::RunLoop run_loop;
+    leveldb()->OpenWithOptions(
+        std::move(options), std::move(directory), "test",
+        MakeRequest(&database, leveldb().associated_group()),
+        Capture(&error, run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_EQ(mojom::DatabaseError::OK, error);
+
+    // Write a key to the database.
+    error = mojom::DatabaseError::INVALID_ARGUMENT;
+    DatabaseSyncPut(database.get(), "key", "value", &error);
+    EXPECT_EQ(mojom::DatabaseError::OK, error);
+
+    // The database should go out of scope here.
+  }
+
+  {
+    filesystem::mojom::DirectoryPtr directory;
+    temp_directory->Clone(MakeRequest(&directory));
+
+    // Destroy the database.
+    base::RunLoop run_loop;
+    leveldb()->Destroy(std::move(directory), "test",
+                       Capture(&error, run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_EQ(mojom::DatabaseError::OK, error);
+  }
+
+  {
+    filesystem::mojom::DirectoryPtr directory;
+    temp_directory->Clone(MakeRequest(&directory));
+
+    // Reconnect to the database should fail.
+    mojom::LevelDBDatabaseAssociatedPtr database;
+    base::RunLoop run_loop;
+    leveldb()->Open(std::move(directory), "test",
+                    MakeRequest(&database, leveldb().associated_group()),
+                    Capture(&error, run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_EQ(mojom::DatabaseError::INVALID_ARGUMENT, error);
+  }
+
+  {
+    filesystem::mojom::DirectoryPtr directory;
+    temp_directory->Clone(MakeRequest(&directory));
+
+    // Destroying a non-existant database should still succeed.
+    base::RunLoop run_loop;
+    leveldb()->Destroy(std::move(directory), "test",
+                       Capture(&error, run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_EQ(mojom::DatabaseError::OK, error);
+  }
+}
+
 TEST_F(LevelDBServiceTest, GetSnapshotSimple) {
   mojom::DatabaseError error;
-  mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
+  mojom::LevelDBDatabaseAssociatedPtr database;
+  LevelDBSyncOpenInMemory(leveldb().get(),
+                          MakeRequest(&database, leveldb().associated_group()),
+                          &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   base::UnguessableToken snapshot;
   base::RunLoop run_loop;
   database->GetSnapshot(CaptureConstRef(&snapshot, run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_FALSE(snapshot.is_empty());
 }
 
 TEST_F(LevelDBServiceTest, GetFromSnapshots) {
   mojom::DatabaseError error;
-  mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
+  mojom::LevelDBDatabaseAssociatedPtr database;
+  LevelDBSyncOpenInMemory(leveldb().get(),
+                          MakeRequest(&database, leveldb().associated_group()),
+                          &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Take a snapshot where key=value.
   base::UnguessableToken key_value_snapshot;
   base::RunLoop run_loop;
@@ skipping 19 matching lines @@
   base::RunLoop run_loop2;
   database->GetFromSnapshot(
       key_value_snapshot, StdStringToUint8Vector("key"),
       CaptureConstRef(&error, &value, run_loop2.QuitClosure()));
   run_loop2.Run();
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   EXPECT_EQ("value", Uint8VectorToStdString(value));
 }
 
 TEST_F(LevelDBServiceTest, InvalidArgumentOnInvalidSnapshot) {
-  mojom::LevelDBDatabasePtr database;
+  mojom::LevelDBDatabaseAssociatedPtr database;
   mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT;
-  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(),
+                          MakeRequest(&database, leveldb().associated_group()),
+                          &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   base::UnguessableToken invalid_snapshot = base::UnguessableToken::Create();
 
   error = mojom::DatabaseError::OK;
   std::vector<uint8_t> value;
   base::RunLoop run_loop;
   database->GetFromSnapshot(
       invalid_snapshot, StdStringToUint8Vector("key"),
       CaptureConstRef(&error, &value, run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_EQ(mojom::DatabaseError::INVALID_ARGUMENT, error);
 }
 
 TEST_F(LevelDBServiceTest, MemoryDBReadWrite) {
-  mojom::LevelDBDatabasePtr database;
+  mojom::LevelDBDatabaseAssociatedPtr database;
   mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT;
-  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(),
+                          MakeRequest(&database, leveldb().associated_group()),
+                          &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Read the key back from the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   std::vector<uint8_t> value;
@@ skipping 13 matching lines @@
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   value.clear();
   DatabaseSyncGet(database.get(), "key", &error, &value);
   EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error);
   EXPECT_EQ("", Uint8VectorToStdString(value));
 }
 
 TEST_F(LevelDBServiceTest, Prefixed) {
   // Open an in memory database for speed.
   mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT;
-  mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
+  mojom::LevelDBDatabaseAssociatedPtr database;
+  LevelDBSyncOpenInMemory(leveldb().get(),
+                          MakeRequest(&database, leveldb().associated_group()),
+                          &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   const std::string prefix("prefix");
   std::vector<mojom::KeyValuePtr> key_values;
 
   // Completely empty database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncGetPrefixed(database.get(), prefix, &error, &key_values);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   EXPECT_TRUE(key_values.empty());
@@ skipping 73 matching lines @@
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   key_values.clear();
   DatabaseSyncGetPrefixed(database.get(), prefix, &error, &key_values);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   EXPECT_TRUE(key_values.empty());
 }
 
 }  // namespace
 }  // namespace leveldb