Store a version number in the localstorage database.

Currently an invalid version just results in not using a backing store,
but in the future that will result in upgrading and/or recreating the
database.

BUG=586194

Review-Url: https://codereview.chromium.org/2607493003
Cr-Commit-Position: refs/heads/master@{#440857}

content/browser/dom_storage/local_storage_context_mojo.cc

@@ -5,6 +5,8 @@
 #include "content/browser/dom_storage/local_storage_context_mojo.h"
 
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "components/leveldb/public/cpp/util.h"
 #include "content/browser/leveldb_wrapper_impl.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "services/file/public/interfaces/constants.mojom.h"
@@ -13,8 +15,24 @@
 
 namespace content {
 
+// LevelDB database schema
+// =======================
+//
+// Version 1 (in sorted order):
+//   key: "VERSION"
+//   value: "1"
+//
+//   key: "_" + <url::Origin> 'origin'> + '\x00' + <script controlled key>
+//   value: <script controlled value>
+
 namespace {
+const char kVersionKey[] = "VERSION";
 const char kOriginSeparator = '\x00';
+const char kDataPrefix[] = "_";
+const int64_t kMinSchemaVersion = 1;
+const int64_t kCurrentSchemaVersion = 1;
+
+void NoOpResult(leveldb::mojom::DatabaseError status) {}
 }
 
 LocalStorageContextMojo::LocalStorageContextMojo(
@@ -72,6 +90,8 @@ void LocalStorageContextMojo::OpenLocalStorage(
 
 void LocalStorageContextMojo::SetDatabaseForTesting(
     leveldb::mojom::LevelDBDatabasePtr database) {
+  DCHECK_EQ(connection_state_, NO_CONNECTION);
+  connection_state_ = CONNECTION_IN_PROGRESS;
   database_ = std::move(database);
   OnDatabaseOpened(leveldb::mojom::DatabaseError::OK);
 }
@@ -125,7 +145,46 @@ void LocalStorageContextMojo::OnDatabaseOpened(
   directory_.reset();
   file_system_.reset();
 
-  // |leveldb_| should be known to either be valid or invalid by now. Run our
+  // Verify DB schema version.
+  if (database_) {
+    database_->Get(leveldb::StdStringToUint8Vector(kVersionKey),
+                   base::Bind(&LocalStorageContextMojo::OnGotDatabaseVersion,
+                              weak_ptr_factory_.GetWeakPtr()));
+    return;
+  }
+
+  OnGotDatabaseVersion(leveldb::mojom::DatabaseError::IO_ERROR,
+                       std::vector<uint8_t>());
+}
+
+void LocalStorageContextMojo::OnGotDatabaseVersion(
+    leveldb::mojom::DatabaseError status,
+    const std::vector<uint8_t>& value) {
+  if (status == leveldb::mojom::DatabaseError::NOT_FOUND) {
+    // New database, write current version and continue.
+    // TODO(mek): Delay writing version until first actual data gets committed.
+    database_->Put(leveldb::StdStringToUint8Vector(kVersionKey),
+                   leveldb::StdStringToUint8Vector(
+                       base::Int64ToString(kCurrentSchemaVersion)),
+                   base::Bind(&NoOpResult));
+    // new database
+  } else if (status == leveldb::mojom::DatabaseError::OK) {
+    // Existing database, check if version number matches current schema
+    // version.
+    int64_t db_version;
+    if (!base::StringToInt64(leveldb::Uint8VectorToStdString(value),
+                             &db_version) ||
+        db_version < kMinSchemaVersion || db_version > kCurrentSchemaVersion) {
+      // TODO(mek): delete and recreate database, rather than failing outright.
+      database_ = nullptr;
+    }
+  } else {
+    // Other read error. Possibly database corruption.
+    // TODO(mek): delete and recreate database, rather than failing outright.
+    database_ = nullptr;
+  }
+
+  // |database_| should be known to either be valid or invalid by now. Run our
   // delayed bindings.
   connection_state_ = CONNECTION_FINISHED;
   for (size_t i = 0; i < on_database_opened_callbacks_.size(); ++i)
@@ -150,7 +209,7 @@ void LocalStorageContextMojo::BindLocalStorage(
   auto found = level_db_wrappers_.find(origin);
   if (found == level_db_wrappers_.end()) {
     level_db_wrappers_[origin] = base::MakeUnique<LevelDBWrapperImpl>(
-        database_.get(), origin.Serialize() + kOriginSeparator,
+        database_.get(), kDataPrefix + origin.Serialize() + kOriginSeparator,
         kPerStorageAreaQuota + kPerStorageAreaOverQuotaAllowance,
         base::TimeDelta::FromSeconds(kCommitDefaultDelaySecs), kMaxBytesPerHour,
         kMaxCommitsPerHour,

content/browser/dom_storage/local_storage_context_mojo.h

@@ -43,6 +43,8 @@ class CONTENT_EXPORT LocalStorageContextMojo {
   // Part of our asynchronous directory opening called from OpenLocalStorage().
   void OnDirectoryOpened(filesystem::mojom::FileError err);
   void OnDatabaseOpened(leveldb::mojom::DatabaseError status);
+  void OnGotDatabaseVersion(leveldb::mojom::DatabaseError status,
+                            const std::vector<uint8_t>& value);
 
   // The (possibly delayed) implementation of OpenLocalStorage(). Can be called
   // directly from that function, or through |on_database_open_callbacks_|.

content/browser/dom_storage/local_storage_context_mojo_unittest.cc

@@ -20,29 +20,45 @@ namespace {
 
 void NoOpSuccess(bool success) {}
 
+void GetCallback(const base::Closure& callback,
+                 bool* success_out,
+                 std::vector<uint8_t>* value_out,
+                 bool success,
+                 const std::vector<uint8_t>& value) {
+  *success_out = success;
+  *value_out = value;
+  callback.Run();
+}
+
 }  // namespace
 
 class LocalStorageContextMojoTest : public testing::Test {
  public:
-  LocalStorageContextMojoTest()
-      : db_(&mock_data_),
-        db_binding_(&db_),
-        context_(nullptr, base::FilePath()) {
-    context_.SetDatabaseForTesting(db_binding_.CreateInterfacePtrAndBind());
+  LocalStorageContextMojoTest() : db_(&mock_data_), db_binding_(&db_) {}
+
+  LocalStorageContextMojo* context() {
+    if (!context_) {
+      context_ =
+          base::MakeUnique<LocalStorageContextMojo>(nullptr, base::FilePath());
+      context_->SetDatabaseForTesting(db_binding_.CreateInterfacePtrAndBind());
+    }
+    return context_.get();
   }
-
-  LocalStorageContextMojo* context() { return &context_; }
   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);
+  }
+
  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_;
 
-  LocalStorageContextMojo context_;
+  std::unique_ptr<LocalStorageContextMojo> context_;
 };
 
 TEST_F(LocalStorageContextMojoTest, Basic) {
@@ -56,8 +72,8 @@ TEST_F(LocalStorageContextMojoTest, Basic) {
   wrapper.reset();
 
   base::RunLoop().RunUntilIdle();
-  ASSERT_EQ(1u, mock_data().size());
-  EXPECT_EQ(value, mock_data().begin()->second);
+  ASSERT_EQ(2u, mock_data().size());
+  EXPECT_EQ(value, mock_data().rbegin()->second);
 }
 
 TEST_F(LocalStorageContextMojoTest, OriginsAreIndependent) {
@@ -77,8 +93,45 @@ TEST_F(LocalStorageContextMojoTest, OriginsAreIndependent) {
   wrapper.reset();
 
   base::RunLoop().RunUntilIdle();
-  ASSERT_EQ(2u, mock_data().size());
-  EXPECT_EQ(value, mock_data().begin()->second);
+  ASSERT_EQ(3u, mock_data().size());
+  EXPECT_EQ(value, mock_data().rbegin()->second);
+}
+
+TEST_F(LocalStorageContextMojoTest, ValidVersion) {
+  set_mock_data("VERSION", "1");
+  set_mock_data(std::string("_http://foobar.com") + '\x00' + "key", "value");
+
+  mojom::LevelDBWrapperPtr wrapper;
+  context()->OpenLocalStorage(url::Origin(GURL("http://foobar.com")),
+                              MakeRequest(&wrapper));
+
+  base::RunLoop run_loop;
+  bool success = false;
+  std::vector<uint8_t> result;
+  wrapper->Get(
+      StdStringToUint8Vector("key"),
+      base::Bind(&GetCallback, run_loop.QuitClosure(), &success, &result));
+  run_loop.Run();
+  EXPECT_TRUE(success);
+  EXPECT_EQ(StdStringToUint8Vector("value"), result);
+}
+
+TEST_F(LocalStorageContextMojoTest, InvalidVersion) {
+  set_mock_data("VERSION", "foobar");
+  set_mock_data(std::string("_http://foobar.com") + '\x00' + "key", "value");
+
+  mojom::LevelDBWrapperPtr wrapper;
+  context()->OpenLocalStorage(url::Origin(GURL("http://foobar.com")),
+                              MakeRequest(&wrapper));
+
+  base::RunLoop run_loop;
+  bool success = false;
+  std::vector<uint8_t> result;
+  wrapper->Get(
+      StdStringToUint8Vector("key"),
+      base::Bind(&GetCallback, run_loop.QuitClosure(), &success, &result));
+  run_loop.Run();
+  EXPECT_FALSE(success);
 }
 
 }  // namespace content

content/browser/leveldb_wrapper_impl.cc

@@ -243,6 +243,12 @@ void LevelDBWrapperImpl::LoadMap(const base::Closure& completion_callback) {
   if (on_load_complete_tasks_.size() > 1)
     return;
 
+  if (!database_) {
+    OnLoadComplete(leveldb::mojom::DatabaseError::IO_ERROR,
+                   std::vector<leveldb::mojom::KeyValuePtr>());
+    return;
+  }
+
   // TODO(michaeln): Import from sqlite localstorage db.
   database_->GetPrefixed(prefix_,
                          base::Bind(&LevelDBWrapperImpl::OnLoadComplete,