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

content/browser/dom_storage/local_storage_context_mojo_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 "content/browser/dom_storage/local_storage_context_mojo.h"
 
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "components/filesystem/public/interfaces/file_system.mojom.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/mock_leveldb_database.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/file/file_service.h"
 #include "services/file/public/interfaces/constants.mojom.h"
 #include "services/file/user_id_map.h"
 #include "services/service_manager/public/cpp/interface_factory.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/cpp/service_test.h"
 #include "services/service_manager/public/interfaces/service_factory.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/leveldatabase/env_chromium.h"
+#include "third_party/leveldatabase/src/include/leveldb/db.h"
 
 using leveldb::StdStringToUint8Vector;
 using leveldb::Uint8VectorToStdString;
 
 namespace content {
 
 namespace {
 
 void NoOpSuccess(bool success) {}
 
@@ skipping 67 matching lines @@
 }  // namespace
 
 class LocalStorageContextMojoTest : public testing::Test {
  public:
   LocalStorageContextMojoTest() : db_(&mock_data_), db_binding_(&db_) {}
 
   LocalStorageContextMojo* context() {
     if (!context_) {
       context_ =
           base::MakeUnique<LocalStorageContextMojo>(nullptr, base::FilePath());
-      context_->SetDatabaseForTesting(db_binding_.CreateInterfacePtrAndBind());
+      db_binding_.Bind(context_->DatabaseRequestForTesting());
     }
     return context_.get();
   }
   const std::map<std::vector<uint8_t>, std::vector<uint8_t>>& mock_data() {
     return mock_data_;
   }
 
   void set_mock_data(const std::string& key, const std::string& value) {
     mock_data_[StdStringToUint8Vector(key)] = StdStringToUint8Vector(value);
   }
 
   std::vector<LocalStorageUsageInfo> GetStorageUsageSync() {
     base::RunLoop run_loop;
     std::vector<LocalStorageUsageInfo> result;
     context()->GetStorageUsage(base::BindOnce(&GetStorageUsageCallback,
                                               run_loop.QuitClosure(), &result));
     run_loop.Run();
     return result;
   }
 
  private:
   TestBrowserThreadBundle thread_bundle_;
   std::map<std::vector<uint8_t>, std::vector<uint8_t>> mock_data_;
   MockLevelDBDatabase db_;
-  mojo::Binding<leveldb::mojom::LevelDBDatabase> db_binding_;
+  mojo::AssociatedGroup associated_group_;
+  mojo::AssociatedBinding<leveldb::mojom::LevelDBDatabase> db_binding_;
 
   std::unique_ptr<LocalStorageContextMojo> context_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalStorageContextMojoTest);
 };
 
 TEST_F(LocalStorageContextMojoTest, Basic) {
   auto key = StdStringToUint8Vector("key");
   auto value = StdStringToUint8Vector("value");
 
@@ skipping 574 matching lines @@
 
   // Should have created files.
   EXPECT_EQ(test_path, FirstEntryInDir().BaseName());
 
   // Should be able to re-open.
   context.reset(new LocalStorageContextMojo(connector(), test_path));
   EXPECT_TRUE(DoTestGet(context.get(), key, &result));
   EXPECT_EQ(value, result);
 }
 
+// Enable when http://crbug.com/677194 is fixed and ServiceTest works
+// correctly on Android.
+#if defined(OS_ANDROID)
+#define MAYBE_InvalidVersionOnDisk DISABLED_InvalidVersionOnDisk
+#else
+#define MAYBE_InvalidVersionOnDisk InvalidVersionOnDisk
+#endif
+TEST_F(LocalStorageContextMojoTestWithService, MAYBE_InvalidVersionOnDisk) {
+  base::FilePath test_path(FILE_PATH_LITERAL("test_path"));
+
+  // Create context and add some data to it.
+  auto context =
+      base::MakeUnique<LocalStorageContextMojo>(connector(), test_path);
+  auto key = StdStringToUint8Vector("key");
+  auto value = StdStringToUint8Vector("value");
+
+  DoTestPut(context.get(), key, value);
+  std::vector<uint8_t> result;
+  EXPECT_TRUE(DoTestGet(context.get(), key, &result));
+  EXPECT_EQ(value, result);
+
+  context.reset();
+  base::RunLoop().RunUntilIdle();
+
+  {
+    // Mess up version number in database.
+    leveldb_env::ChromiumEnv env;
+    leveldb::DB* db = nullptr;
+    leveldb::Options options;
+    options.env = &env;
+    base::FilePath db_path =
+        temp_path().Append(test_path).Append(FILE_PATH_LITERAL("leveldb"));
+    ASSERT_TRUE(leveldb::DB::Open(options, db_path.AsUTF8Unsafe(), &db).ok());
+    std::unique_ptr<leveldb::DB> db_owner(db);
+    ASSERT_TRUE(db->Put(leveldb::WriteOptions(), "VERSION", "argh").ok());
+  }
+
+  // Make sure data is gone.
+  context = base::MakeUnique<LocalStorageContextMojo>(connector(), test_path);
+  EXPECT_FALSE(DoTestGet(context.get(), key, &result));
+
+  // Write data again.
+  DoTestPut(context.get(), key, value);
+
+  context.reset();
+  base::RunLoop().RunUntilIdle();
+
+  // Data should have been preserved now.
+  context = base::MakeUnique<LocalStorageContextMojo>(connector(), test_path);
+  EXPECT_TRUE(DoTestGet(context.get(), key, &result));
+  EXPECT_EQ(value, result);
+}
+
 }  // namespace content