// Copyright 2018 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/session_storage_metadata.h"

#include "base/bind.h"
#include "base/files/scoped_temp_dir.h"
#include "base/guid.h"
#include "base/memory/ptr_util.h"
#include "base/run_loop.h"
#include "base/stl_util.h"
#include "base/strings/string16.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/scoped_task_environment.h"
#include "components/services/leveldb/public/cpp/util.h"
#include "content/browser/dom_storage/session_storage_database.h"
#include "content/browser/indexed_db/leveldb/leveldb_env.h"
#include "content/common/dom_storage/dom_storage_types.h"
#include "content/test/fake_leveldb_database.h"
#include "mojo/public/cpp/bindings/strong_associated_binding.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/leveldatabase/env_chromium.h"
#include "third_party/leveldatabase/leveldb_chrome.h"
#include "third_party/leveldatabase/src/include/leveldb/db.h"
#include "third_party/leveldatabase/src/include/leveldb/options.h"
#include "url/gurl.h"
#include "url/origin.h"

namespace content {
namespace {
using leveldb::StdStringToUint8Vector;
using leveldb::Uint8VectorToStdString;
using leveldb::mojom::DatabaseError;

void GetCallback(std::vector<uint8_t>* value_out,
                 DatabaseError error,
                 const std::vector<uint8_t>& value) {
  *value_out = value;
}

void ErrorCallback(DatabaseError* error_out, DatabaseError error) {
  *error_out = error;
}

void GetAllCallback(std::vector<leveldb::mojom::KeyValuePtr>* values_out,
                    DatabaseError error,
                    std::vector<leveldb::mojom::KeyValuePtr> values) {
  *values_out = std::move(values);
}

class SessionStorageMetadataTest : public testing::Test {
 public:
  SessionStorageMetadataTest()
      : test_namespace1_id_(base::GenerateGUID()),
        test_namespace2_id_(base::GenerateGUID()),
        test_namespace3_id_(base::GenerateGUID()),
        test_origin1_(url::Origin::Create(GURL("http://host1:1/"))),
        test_origin2_(url::Origin::Create(GURL("http://host2:2/"))),
        database_(&mock_data_) {
    next_map_id_key_ = std::vector<uint8_t>(
        std::begin(SessionStorageMetadata::kNextMapIdKeyBytes),
        std::end(SessionStorageMetadata::kNextMapIdKeyBytes));
    database_version_key_ = std::vector<uint8_t>(
        std::begin(SessionStorageMetadata::kDatabaseVersionBytes),
        std::end(SessionStorageMetadata::kDatabaseVersionBytes));
    namespaces_prefix_key_ = std::vector<uint8_t>(
        std::begin(SessionStorageMetadata::kNamespacePrefixBytes),
        std::end(SessionStorageMetadata::kNamespacePrefixBytes));
  }
  ~SessionStorageMetadataTest() override {}

  void ReadMetadataFromDatabase(SessionStorageMetadata* metadata) {
    std::vector<uint8_t> value;
    database_.Get(database_version_key_, base::BindOnce(&GetCallback, &value));
    std::vector<leveldb::mojom::BatchedOperationPtr> migration_operations;
    EXPECT_TRUE(metadata->ParseDatabaseVersion(value, &migration_operations));
    EXPECT_TRUE(migration_operations.empty());
    database_.Get(next_map_id_key_, base::BindOnce(&GetCallback, &value));
    metadata->ParseNextMapId(value);
    std::vector<leveldb::mojom::KeyValuePtr> values;
    database_.GetPrefixed(namespaces_prefix_key_,
                          base::BindOnce(&GetAllCallback, &values));
    EXPECT_TRUE(
        metadata->ParseNamespaces(std::move(values), &migration_operations));
    EXPECT_TRUE(migration_operations.empty());
  }

  void SetupTestData() {
    // | key                                    | value              |
    // |----------------------------------------|--------------------|
    // | map-1-key1                             | data1              |
    // | map-3-key1                             | data3              |
    // | map-4-key1                             | data4              |
    // | namespace-<guid 1>-http://host1:1/     | 1                  |
    // | namespace-<guid 1>-http://host2:2/     | 3                  |
    // | namespace-<guid 2>-http://host1:1/     | 1                  |
    // | namespace-<guid 2>-http://host2:2/     | 4                  |
    // | next-map-id                            | 5                  |
    // | version                                | 1                  |
    mock_data_[StdStringToUint8Vector(
        std::string("namespace-") + test_namespace1_id_ + "-" +
        test_origin1_.GetURL().spec())] = StdStringToUint8Vector("1");
    mock_data_[StdStringToUint8Vector(
        std::string("namespace-") + test_namespace1_id_ + "-" +
        test_origin2_.GetURL().spec())] = StdStringToUint8Vector("3");
    mock_data_[StdStringToUint8Vector(
        std::string("namespace-") + test_namespace2_id_ + "-" +
        test_origin1_.GetURL().spec())] = StdStringToUint8Vector("1");
    mock_data_[StdStringToUint8Vector(
        std::string("namespace-") + test_namespace2_id_ + "-" +
        test_origin2_.GetURL().spec())] = StdStringToUint8Vector("4");

    mock_data_[next_map_id_key_] = StdStringToUint8Vector("5");

    mock_data_[StdStringToUint8Vector("map-1-key1")] =
        StdStringToUint8Vector("data1");
    mock_data_[StdStringToUint8Vector("map-3-key1")] =
        StdStringToUint8Vector("data3");
    mock_data_[StdStringToUint8Vector("map-4-key1")] =
        StdStringToUint8Vector("data4");

    mock_data_[database_version_key_] = StdStringToUint8Vector("1");
  }

 protected:
  base::test::ScopedTaskEnvironment scoped_task_environment_;
  std::string test_namespace1_id_;
  std::string test_namespace2_id_;
  std::string test_namespace3_id_;
  url::Origin test_origin1_;
  url::Origin test_origin2_;
  std::map<std::vector<uint8_t>, std::vector<uint8_t>> mock_data_;
  FakeLevelDBDatabase database_;

  std::vector<uint8_t> database_version_key_;
  std::vector<uint8_t> next_map_id_key_;
  std::vector<uint8_t> namespaces_prefix_key_;
};

TEST_F(SessionStorageMetadataTest, SaveNewMetadata) {
  SessionStorageMetadata metadata;
  std::vector<leveldb::mojom::BatchedOperationPtr> operations =
      metadata.SetupNewDatabase();

  DatabaseError error;
  database_.Write(std::move(operations),
                  base::BindOnce(&ErrorCallback, &error));
  EXPECT_EQ(DatabaseError::OK, error);

  EXPECT_EQ(StdStringToUint8Vector("1"), mock_data_[database_version_key_]);
  EXPECT_EQ(StdStringToUint8Vector("0"), mock_data_[next_map_id_key_]);
}

TEST_F(SessionStorageMetadataTest, LoadingData) {
  SetupTestData();
  SessionStorageMetadata metadata;
  ReadMetadataFromDatabase(&metadata);

  EXPECT_EQ(5, metadata.NextMapId());
  EXPECT_EQ(2ul, metadata.namespace_origin_map().size());

  // Namespace 1 should have 2 origins, referencing map 1 and 3. Map 1 is shared
  // between namespace 1 and namespace 2.
  auto entry = metadata.GetOrCreateNamespaceEntry(test_namespace1_id_);
  EXPECT_EQ(test_namespace1_id_, entry->first);
  EXPECT_EQ(2ul, entry->second.size());
  EXPECT_EQ(StdStringToUint8Vector("map-1-"),
            entry->second[test_origin1_]->KeyPrefix());
  EXPECT_EQ(2, entry->second[test_origin1_]->ReferenceCount());
  EXPECT_EQ(StdStringToUint8Vector("map-3-"),
            entry->second[test_origin2_]->KeyPrefix());
  EXPECT_EQ(1, entry->second[test_origin2_]->ReferenceCount());

  // Namespace 2 is the same, except the second origin references map 4.
  entry = metadata.GetOrCreateNamespaceEntry(test_namespace2_id_);
  EXPECT_EQ(test_namespace2_id_, entry->first);
  EXPECT_EQ(2ul, entry->second.size());
  EXPECT_EQ(StdStringToUint8Vector("map-1-"),
            entry->second[test_origin1_]->KeyPrefix());
  EXPECT_EQ(2, entry->second[test_origin1_]->ReferenceCount());
  EXPECT_EQ(StdStringToUint8Vector("map-4-"),
            entry->second[test_origin2_]->KeyPrefix());
  EXPECT_EQ(1, entry->second[test_origin2_]->ReferenceCount());
}

TEST_F(SessionStorageMetadataTest, SaveNewMap) {
  SetupTestData();
  SessionStorageMetadata metadata;
  ReadMetadataFromDatabase(&metadata);

  std::vector<leveldb::mojom::BatchedOperationPtr> operations;
  auto ns1_entry = metadata.GetOrCreateNamespaceEntry(test_namespace1_id_);
  auto map_data =
      metadata.RegisterNewMap(ns1_entry, test_origin1_, &operations);
  ASSERT_TRUE(map_data);

  // Verify in-memory metadata is correct.
  EXPECT_EQ(StdStringToUint8Vector("map-5-"),
            ns1_entry->second[test_origin1_]->KeyPrefix());
  EXPECT_EQ(1, ns1_entry->second[test_origin1_]->ReferenceCount());
  EXPECT_EQ(1, metadata.GetOrCreateNamespaceEntry(test_namespace2_id_)
                   ->second[test_origin1_]
                   ->ReferenceCount());

  DatabaseError error;
  database_.Write(std::move(operations),
                  base::BindOnce(&ErrorCallback, &error));
  EXPECT_EQ(DatabaseError::OK, error);

  // Verify metadata was written to disk.
  EXPECT_EQ(StdStringToUint8Vector("6"), mock_data_[next_map_id_key_]);
  EXPECT_EQ(StdStringToUint8Vector("5"),
            mock_data_[StdStringToUint8Vector(std::string("namespace-") +
                                              test_namespace1_id_ + "-" +
                                              test_origin1_.GetURL().spec())]);
}

TEST_F(SessionStorageMetadataTest, ShallowCopies) {
  SetupTestData();
  SessionStorageMetadata metadata;
  ReadMetadataFromDatabase(&metadata);

  auto ns1_entry = metadata.GetOrCreateNamespaceEntry(test_namespace1_id_);
  auto ns3_entry = metadata.GetOrCreateNamespaceEntry(test_namespace3_id_);

  std::vector<leveldb::mojom::BatchedOperationPtr> operations;
  metadata.RegisterShallowClonedNamespace(ns1_entry, ns3_entry, &operations);

  DatabaseError error;
  database_.Write(std::move(operations),
                  base::BindOnce(&ErrorCallback, &error));
  EXPECT_EQ(DatabaseError::OK, error);

  // Verify in-memory metadata is correct.
  EXPECT_EQ(StdStringToUint8Vector("map-1-"),
            ns3_entry->second[test_origin1_]->KeyPrefix());
  EXPECT_EQ(StdStringToUint8Vector("map-3-"),
            ns3_entry->second[test_origin2_]->KeyPrefix());
  EXPECT_EQ(ns1_entry->second[test_origin1_].get(),
            ns3_entry->second[test_origin1_].get());
  EXPECT_EQ(ns1_entry->second[test_origin2_].get(),
            ns3_entry->second[test_origin2_].get());
  EXPECT_EQ(3, ns3_entry->second[test_origin1_]->ReferenceCount());
  EXPECT_EQ(2, ns3_entry->second[test_origin2_]->ReferenceCount());

  // Verify metadata was written to disk.
  EXPECT_EQ(StdStringToUint8Vector("1"),
            mock_data_[StdStringToUint8Vector(std::string("namespace-") +
                                              test_namespace3_id_ + "-" +
                                              test_origin1_.GetURL().spec())]);
  EXPECT_EQ(StdStringToUint8Vector("3"),
            mock_data_[StdStringToUint8Vector(std::string("namespace-") +
                                              test_namespace3_id_ + "-" +
                                              test_origin2_.GetURL().spec())]);
}

TEST_F(SessionStorageMetadataTest, DeleteNamespace) {
  SetupTestData();
  SessionStorageMetadata metadata;
  ReadMetadataFromDatabase(&metadata);

  std::vector<leveldb::mojom::BatchedOperationPtr> operations;
  metadata.DeleteNamespace(test_namespace1_id_, &operations);
  DatabaseError error;
  database_.Write(std::move(operations),
                  base::BindOnce(&ErrorCallback, &error));
  EXPECT_EQ(DatabaseError::OK, error);

  EXPECT_FALSE(
      base::ContainsKey(metadata.namespace_origin_map(), test_namespace1_id_));

  // Verify in-memory metadata is correct.
  auto ns2_entry = metadata.GetOrCreateNamespaceEntry(test_namespace2_id_);
  EXPECT_EQ(1, ns2_entry->second[test_origin1_]->ReferenceCount());
  EXPECT_EQ(1, ns2_entry->second[test_origin2_]->ReferenceCount());

  // Verify metadata and data was deleted from disk.
  EXPECT_FALSE(base::ContainsKey(
      mock_data_,
      StdStringToUint8Vector(std::string("namespace-") + test_namespace1_id_ +
                             "-" + test_origin1_.GetURL().spec())));
  EXPECT_FALSE(base::ContainsKey(
      mock_data_,
      StdStringToUint8Vector(std::string("namespace-") + test_namespace1_id_ +
                             "-" + test_origin2_.GetURL().spec())));
  EXPECT_FALSE(
      base::ContainsKey(mock_data_, StdStringToUint8Vector("map-3-key1")));
  EXPECT_TRUE(
      base::ContainsKey(mock_data_, StdStringToUint8Vector("map-1-key1")));
}

TEST_F(SessionStorageMetadataTest, DeleteArea) {
  SetupTestData();
  SessionStorageMetadata metadata;
  ReadMetadataFromDatabase(&metadata);

  // First delete an area with a shared map.
  std::vector<leveldb::mojom::BatchedOperationPtr> operations;
  metadata.DeleteArea(test_namespace1_id_, test_origin1_, &operations);
  DatabaseError error;
  database_.Write(std::move(operations),
                  base::BindOnce(&ErrorCallback, &error));
  EXPECT_EQ(DatabaseError::OK, error);

  // Verify in-memory metadata is correct.
  auto ns1_entry = metadata.GetOrCreateNamespaceEntry(test_namespace1_id_);
  auto ns2_entry = metadata.GetOrCreateNamespaceEntry(test_namespace2_id_);
  EXPECT_FALSE(base::ContainsKey(ns1_entry->second, test_origin1_));
  EXPECT_EQ(1, ns1_entry->second[test_origin2_]->ReferenceCount());
  EXPECT_EQ(1, ns2_entry->second[test_origin1_]->ReferenceCount());
  EXPECT_EQ(1, ns2_entry->second[test_origin2_]->ReferenceCount());

  // Verify only the applicable data was deleted.
  EXPECT_FALSE(base::ContainsKey(
      mock_data_,
      StdStringToUint8Vector(std::string("namespace-") + test_namespace1_id_ +
                             "-" + test_origin1_.GetURL().spec())));
  EXPECT_TRUE(base::ContainsKey(
      mock_data_,
      StdStringToUint8Vector(std::string("namespace-") + test_namespace1_id_ +
                             "-" + test_origin2_.GetURL().spec())));
  EXPECT_TRUE(
      base::ContainsKey(mock_data_, StdStringToUint8Vector("map-1-key1")));
  EXPECT_TRUE(
      base::ContainsKey(mock_data_, StdStringToUint8Vector("map-4-key1")));

  // Now delete an area with a unique map.
  operations.clear();
  metadata.DeleteArea(test_namespace2_id_, test_origin2_, &operations);
  database_.Write(std::move(operations),
                  base::BindOnce(&ErrorCallback, &error));
  EXPECT_EQ(DatabaseError::OK, error);

  // Verify in-memory metadata is correct.
  EXPECT_FALSE(base::ContainsKey(ns1_entry->second, test_origin1_));
  EXPECT_EQ(1, ns1_entry->second[test_origin2_]->ReferenceCount());
  EXPECT_EQ(1, ns2_entry->second[test_origin1_]->ReferenceCount());
  EXPECT_FALSE(base::ContainsKey(ns2_entry->second, test_origin2_));

  // Verify only the applicable data was deleted.
  EXPECT_TRUE(base::ContainsKey(
      mock_data_,
      StdStringToUint8Vector(std::string("namespace-") + test_namespace2_id_ +
                             "-" + test_origin1_.GetURL().spec())));
  EXPECT_FALSE(base::ContainsKey(
      mock_data_,
      StdStringToUint8Vector(std::string("namespace-") + test_namespace2_id_ +
                             "-" + test_origin2_.GetURL().spec())));
  EXPECT_TRUE(
      base::ContainsKey(mock_data_, StdStringToUint8Vector("map-1-key1")));
  EXPECT_TRUE(
      base::ContainsKey(mock_data_, StdStringToUint8Vector("map-3-key1")));
  EXPECT_FALSE(
      base::ContainsKey(mock_data_, StdStringToUint8Vector("map-4-key1")));
}

class SessionStorageMetadataMigrationTest : public testing::Test {
 public:
  SessionStorageMetadataMigrationTest()
      : test_namespace1_id_(base::GenerateGUID()),
        test_namespace2_id_(base::GenerateGUID()),
        test_origin1_(url::Origin::Create(GURL("http://host1:1/"))) {
    next_map_id_key_ = std::vector<uint8_t>(
        std::begin(SessionStorageMetadata::kNextMapIdKeyBytes),
        std::end(SessionStorageMetadata::kNextMapIdKeyBytes));
    database_version_key_ = std::vector<uint8_t>(
        std::begin(SessionStorageMetadata::kDatabaseVersionBytes),
        std::end(SessionStorageMetadata::kDatabaseVersionBytes));
    namespaces_prefix_key_ = std::vector<uint8_t>(
        std::begin(SessionStorageMetadata::kNamespacePrefixBytes),
        std::end(SessionStorageMetadata::kNamespacePrefixBytes));
  }
  ~SessionStorageMetadataMigrationTest() override = default;

  void SetUp() override {
    ASSERT_TRUE(temp_path_.CreateUniqueTempDir());
    in_memory_env_ =
        leveldb_chrome::NewMemEnv("SessionStorage", LevelDBEnv::Get());
    leveldb_env::Options options;
    options.create_if_missing = true;
    options.env = in_memory_env_.get();
    std::unique_ptr<leveldb::DB> db;
    leveldb::Status s =
        leveldb_env::OpenDB(options, temp_path_.GetPath().AsUTF8Unsafe(), &db);
    ASSERT_TRUE(s.ok()) << s.ToString();
    old_ss_database_ = base::MakeRefCounted<SessionStorageDatabase>(
        temp_path_.GetPath(), base::ThreadTaskRunnerHandle::Get().get());
    old_ss_database_->SetDatabaseForTesting(std::move(db));
  }

  leveldb::DB* db() { return old_ss_database_->db(); }

 protected:
  base::test::ScopedTaskEnvironment scoped_task_environment_;
  base::ScopedTempDir temp_path_;
  std::string test_namespace1_id_;
  std::string test_namespace2_id_;
  url::Origin test_origin1_;
  std::unique_ptr<leveldb::Env> in_memory_env_;
  scoped_refptr<SessionStorageDatabase> old_ss_database_;

  std::vector<uint8_t> database_version_key_;
  std::vector<uint8_t> next_map_id_key_;
  std::vector<uint8_t> namespaces_prefix_key_;
};

TEST_F(SessionStorageMetadataMigrationTest, MigrateV0ToV1) {
  base::string16 key = base::ASCIIToUTF16("key");
  base::string16 value = base::ASCIIToUTF16("value");
  base::string16 key2 = base::ASCIIToUTF16("key2");
  key2.push_back(0xd83d);
  key2.push_back(0xde00);
  DOMStorageValuesMap data;
  data[key] = base::NullableString16(value, false);
  data[key2] = base::NullableString16(value, false);
  EXPECT_TRUE(old_ss_database_->CommitAreaChanges(test_namespace1_id_,
                                                  test_origin1_, false, data));
  EXPECT_TRUE(old_ss_database_->CloneNamespace(test_namespace1_id_,
                                               test_namespace2_id_));

  SessionStorageMetadata metadata;
  // Read non-existant version, give new version to save.
  leveldb::ReadOptions options;
  std::string db_value;
  leveldb::Status s = db()->Get(options, leveldb::Slice("version"), &db_value);
  EXPECT_TRUE(s.IsNotFound());
  std::vector<leveldb::mojom::BatchedOperationPtr> migration_operations;
  EXPECT_TRUE(
      metadata.ParseDatabaseVersion(base::nullopt, &migration_operations));
  EXPECT_FALSE(migration_operations.empty());
  EXPECT_EQ(1ul, migration_operations.size());

  // Grab the next map id, verify it doesn't crash.
  s = db()->Get(options, leveldb::Slice("next-map-id"), &db_value);
  EXPECT_TRUE(s.ok());
  metadata.ParseNextMapId(leveldb::StdStringToUint8Vector(db_value));

  // Get all keys-value pairs with the given key prefix
  std::vector<leveldb::mojom::KeyValuePtr> values;
  {
    std::unique_ptr<leveldb::Iterator> it(db()->NewIterator(options));
    it->Seek(leveldb::Slice("namespace-"));
    for (; it->Valid(); it->Next()) {
      if (!it->key().starts_with(leveldb::Slice("namespace-")))
        break;
      leveldb::mojom::KeyValuePtr kv = leveldb::mojom::KeyValue::New();
      kv->key = leveldb::GetVectorFor(it->key());
      kv->value = leveldb::GetVectorFor(it->value());
      values.push_back(std::move(kv));
    }
    EXPECT_TRUE(it->status().ok());
  }

  EXPECT_TRUE(
      metadata.ParseNamespaces(std::move(values), &migration_operations));
  EXPECT_FALSE(migration_operations.empty());
  EXPECT_EQ(3ul, migration_operations.size());

  EXPECT_TRUE(base::ContainsValue(
      migration_operations,
      leveldb::mojom::BatchedOperation::New(
          leveldb::mojom::BatchOperationType::PUT_KEY,
          StdStringToUint8Vector("version"), StdStringToUint8Vector("1"))));
  EXPECT_TRUE(base::ContainsValue(
      migration_operations,
      leveldb::mojom::BatchedOperation::New(
          leveldb::mojom::BatchOperationType::DELETE_KEY,
          StdStringToUint8Vector("map-0-"), base::nullopt)));
  EXPECT_TRUE(base::ContainsValue(
      migration_operations,
      leveldb::mojom::BatchedOperation::New(
          leveldb::mojom::BatchOperationType::DELETE_KEY,
          StdStringToUint8Vector("namespace-"), base::nullopt)));
}

}  // namespace

}  // namespace content