/*
 * Copyright (C) 2011 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "third_party/blink/renderer/bindings/modules/v8/v8_binding_for_modules.h"

#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-shared.h"
#include "third_party/blink/public/platform/web_blob_info.h"
#include "third_party/blink/public/platform/web_data.h"
#include "third_party/blink/public/platform/web_string.h"
#include "third_party/blink/renderer/bindings/core/v8/serialization/serialization_tag.h"
#include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value.h"
#include "third_party/blink/renderer/bindings/core/v8/to_v8_for_core.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_testing.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_object_builder.h"
#include "third_party/blink/renderer/bindings/modules/v8/to_v8_for_modules.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_any.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_key.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_key_path.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_value.h"
#include "third_party/blink/renderer/platform/bindings/v8_per_isolate_data.h"
#include "third_party/blink/renderer/platform/wtf/shared_buffer.h"
#include "third_party/blink/renderer/platform/wtf/text/string_view.h"

namespace blink {

namespace {

v8::Local<v8::Object> EvaluateScriptAsObject(V8TestingScope& scope,
                                             const char* source) {
  v8::Local<v8::Script> script =
      v8::Script::Compile(scope.GetContext(),
                          V8String(scope.GetIsolate(), source))
          .ToLocalChecked();
  return script->Run(scope.GetContext()).ToLocalChecked().As<v8::Object>();
}

std::unique_ptr<IDBKey> ScriptToKey(V8TestingScope& scope, const char* source) {
  NonThrowableExceptionState exception_state;
  v8::Isolate* isolate = scope.GetIsolate();
  v8::Local<v8::Context> context = scope.GetContext();
  v8::Local<v8::Script> script =
      v8::Script::Compile(context, V8String(isolate, source)).ToLocalChecked();
  v8::Local<v8::Value> value = script->Run(context).ToLocalChecked();
  return ScriptValue::To<std::unique_ptr<IDBKey>>(
      isolate, ScriptValue(isolate, value), exception_state);
}

std::unique_ptr<IDBKey> CheckKeyFromValueAndKeyPathInternal(
    v8::Isolate* isolate,
    const ScriptValue& value,
    const String& key_path) {
  IDBKeyPath idb_key_path(key_path);
  EXPECT_TRUE(idb_key_path.IsValid());

  NonThrowableExceptionState exception_state;
  return ScriptValue::To<std::unique_ptr<IDBKey>>(
      isolate, value, exception_state, idb_key_path);
}

void CheckKeyPathNullValue(v8::Isolate* isolate,
                           const ScriptValue& value,
                           const String& key_path) {
  ASSERT_FALSE(CheckKeyFromValueAndKeyPathInternal(isolate, value, key_path));
}

bool InjectKey(ScriptState* script_state,
               IDBKey* key,
               ScriptValue& value,
               const String& key_path) {
  IDBKeyPath idb_key_path(key_path);
  EXPECT_TRUE(idb_key_path.IsValid());
  ScriptValue key_value = ScriptValue::From(script_state, key);
  return InjectV8KeyIntoV8Value(script_state->GetIsolate(), key_value.V8Value(),
                                value.V8Value(), idb_key_path);
}

void CheckInjection(ScriptState* script_state,
                    IDBKey* key,
                    ScriptValue& value,
                    const String& key_path) {
  bool result = InjectKey(script_state, key, value, key_path);
  ASSERT_TRUE(result);
  std::unique_ptr<IDBKey> extracted_key = CheckKeyFromValueAndKeyPathInternal(
      script_state->GetIsolate(), value, key_path);
  EXPECT_TRUE(key->IsEqual(extracted_key.get()));
}

void CheckInjectionIgnored(ScriptState* script_state,
                           IDBKey* key,
                           ScriptValue& value,
                           const String& key_path) {
  bool result = InjectKey(script_state, key, value, key_path);
  ASSERT_TRUE(result);
  std::unique_ptr<IDBKey> extracted_key = CheckKeyFromValueAndKeyPathInternal(
      script_state->GetIsolate(), value, key_path);
  EXPECT_FALSE(key->IsEqual(extracted_key.get()));
}

void CheckInjectionDisallowed(ScriptState* script_state,
                              ScriptValue& value,
                              const String& key_path) {
  const IDBKeyPath idb_key_path(key_path);
  ASSERT_TRUE(idb_key_path.IsValid());
  EXPECT_FALSE(CanInjectIDBKeyIntoScriptValue(script_state->GetIsolate(), value,
                                              idb_key_path));
}

void CheckKeyPathStringValue(v8::Isolate* isolate,
                             const ScriptValue& value,
                             const String& key_path,
                             const String& expected) {
  std::unique_ptr<IDBKey> idb_key =
      CheckKeyFromValueAndKeyPathInternal(isolate, value, key_path);
  ASSERT_TRUE(idb_key);
  ASSERT_EQ(mojom::IDBKeyType::String, idb_key->GetType());
  ASSERT_TRUE(expected == idb_key->GetString());
}

void CheckKeyPathNumberValue(v8::Isolate* isolate,
                             const ScriptValue& value,
                             const String& key_path,
                             int expected) {
  std::unique_ptr<IDBKey> idb_key =
      CheckKeyFromValueAndKeyPathInternal(isolate, value, key_path);
  ASSERT_TRUE(idb_key);
  ASSERT_EQ(mojom::IDBKeyType::Number, idb_key->GetType());
  ASSERT_TRUE(expected == idb_key->Number());
}

// Compare a key against an array of keys. Supports keys with "holes" (keys of
// type None), so IDBKey::Compare() can't be used directly.
void CheckArrayKey(const IDBKey* key, const IDBKey::KeyArray& expected) {
  EXPECT_EQ(mojom::IDBKeyType::Array, key->GetType());
  const IDBKey::KeyArray& array = key->Array();
  EXPECT_EQ(expected.size(), array.size());
  for (wtf_size_t i = 0; i < array.size(); ++i) {
    EXPECT_EQ(array[i]->GetType(), expected[i]->GetType());
    if (array[i]->GetType() != mojom::IDBKeyType::None) {
      EXPECT_EQ(0, expected[i]->Compare(array[i].get()));
    }
  }
}

// SerializedScriptValue header format offsets are inferred from the Blink and
// V8 serialization code. The code below DCHECKs that
constexpr static size_t kSSVHeaderBlinkVersionTagOffset = 0;
constexpr static size_t kSSVHeaderBlinkVersionOffset = 1;
constexpr static size_t kSSVHeaderV8VersionTagOffset = 2;
// constexpr static size_t kSSVHeaderV8VersionOffset = 3;

// Follows the same steps as the IndexedDB value serialization code.
void SerializeV8Value(v8::Local<v8::Value> value,
                      v8::Isolate* isolate,
                      Vector<char>* wire_bytes) {
  NonThrowableExceptionState non_throwable_exception_state;

  SerializedScriptValue::SerializeOptions options;
  scoped_refptr<SerializedScriptValue> serialized_value =
      SerializedScriptValue::Serialize(isolate, value, options,
                                       non_throwable_exception_state);
  base::span<const uint8_t> ssv_wire_data = serialized_value->GetWireData();
  DCHECK(wire_bytes->IsEmpty());
  wire_bytes->Append(ssv_wire_data.data(),
                     static_cast<wtf_size_t>(ssv_wire_data.size()));

  // Sanity check that the serialization header has not changed, as the tests
  // that use this method rely on the header format.
  //
  // The cast from char* to unsigned char* is necessary to avoid VS2015 warning
  // C4309 (truncation of constant value). This happens because VersionTag is
  // 0xFF.
  const unsigned char* wire_data =
      reinterpret_cast<unsigned char*>(wire_bytes->data());
  ASSERT_EQ(static_cast<unsigned char>(kVersionTag),
            wire_data[kSSVHeaderBlinkVersionTagOffset]);
  ASSERT_EQ(
      static_cast<unsigned char>(SerializedScriptValue::kWireFormatVersion),
      wire_data[kSSVHeaderBlinkVersionOffset]);

  ASSERT_EQ(static_cast<unsigned char>(kVersionTag),
            wire_data[kSSVHeaderV8VersionTagOffset]);
  // TODO(jbroman): Use the compile-time constant for V8 data format version.
  // ASSERT_EQ(v8::ValueSerializer::GetCurrentDataFormatVersion(),
  //           wire_data[kSSVHeaderV8VersionOffset]);
}

std::unique_ptr<IDBValue> CreateIDBValue(v8::Isolate* isolate,
                                         Vector<char>& wire_bytes,
                                         double primary_key,
                                         const String& key_path) {
  WebData web_data(SharedBuffer::AdoptVector(wire_bytes));
  scoped_refptr<SharedBuffer> data(web_data);
  auto value = std::make_unique<IDBValue>(data, Vector<WebBlobInfo>());
  value->SetInjectedPrimaryKey(IDBKey::CreateNumber(primary_key),
                               IDBKeyPath(key_path));

  value->SetIsolate(isolate);
  return value;
}

TEST(IDBKeyFromValueAndKeyPathTest, TopLevelPropertyStringValue) {
  V8TestingScope scope;
  v8::Isolate* isolate = scope.GetIsolate();

  // object = { foo: "zoo" }
  ScriptValue script_value = V8ObjectBuilder(scope.GetScriptState())
                                 .Add("foo", "zoo")
                                 .GetScriptValue();
  CheckKeyPathStringValue(isolate, script_value, "foo", "zoo");
  CheckKeyPathNullValue(isolate, script_value, "bar");
}

}  // namespace

TEST(IDBKeyFromValueAndKeyPathTest, TopLevelPropertyNumberValue) {
  V8TestingScope scope;
  v8::Isolate* isolate = scope.GetIsolate();

  // object = { foo: 456 }
  ScriptValue script_value = V8ObjectBuilder(scope.GetScriptState())
                                 .AddNumber("foo", 456)
                                 .GetScriptValue();
  CheckKeyPathNumberValue(isolate, script_value, "foo", 456);
  CheckKeyPathNullValue(isolate, script_value, "bar");
}

TEST(IDBKeyFromValueAndKeyPathTest, SubProperty) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  v8::Isolate* isolate = scope.GetIsolate();

  // object = { foo: { bar: "zee" } }
  ScriptValue script_value =
      V8ObjectBuilder(script_state)
          .Add("foo", V8ObjectBuilder(script_state).Add("bar", "zee"))
          .GetScriptValue();
  CheckKeyPathStringValue(isolate, script_value, "foo.bar", "zee");
  CheckKeyPathNullValue(isolate, script_value, "bar");
}

TEST(IDBKeyFromValue, Number) {
  V8TestingScope scope;

  auto key = ScriptToKey(scope, "42.0");
  EXPECT_EQ(key->GetType(), mojom::IDBKeyType::Number);
  EXPECT_EQ(key->Number(), 42);

  EXPECT_FALSE(ScriptToKey(scope, "NaN")->IsValid());
}

TEST(IDBKeyFromValue, Date) {
  V8TestingScope scope;

  auto key = ScriptToKey(scope, "new Date(123)");
  EXPECT_EQ(key->GetType(), mojom::IDBKeyType::Date);
  EXPECT_EQ(key->Date(), 123);

  EXPECT_FALSE(ScriptToKey(scope, "new Date(NaN)")->IsValid());
  EXPECT_FALSE(ScriptToKey(scope, "new Date(Infinity)")->IsValid());
}

TEST(IDBKeyFromValue, String) {
  V8TestingScope scope;

  auto key = ScriptToKey(scope, "'abc'");
  EXPECT_EQ(key->GetType(), mojom::IDBKeyType::String);
  EXPECT_EQ(key->GetString(), "abc");
}

TEST(IDBKeyFromValue, Binary) {
  V8TestingScope scope;

  // Key which is an ArrayBuffer.
  {
    auto key = ScriptToKey(scope, "new ArrayBuffer(3)");
    EXPECT_EQ(key->GetType(), mojom::IDBKeyType::Binary);
    EXPECT_EQ(key->Binary()->size(), 3UL);
  }

  // Key which is a TypedArray view on an ArrayBuffer.
  {
    auto key = ScriptToKey(scope, "new Uint8Array([0,1,2])");
    EXPECT_EQ(key->GetType(), mojom::IDBKeyType::Binary);
    EXPECT_EQ(key->Binary()->size(), 3UL);
  }
}

TEST(IDBKeyFromValue, InvalidSimpleKeyTypes) {
  V8TestingScope scope;

  const char* cases[] = {
      "true", "false", "null", "undefined", "{}", "(function(){})", "/regex/",
  };

  for (const char* expr : cases)
    EXPECT_FALSE(ScriptToKey(scope, expr)->IsValid());
}

TEST(IDBKeyFromValue, SimpleArrays) {
  V8TestingScope scope;

  {
    auto key = ScriptToKey(scope, "[]");
    EXPECT_EQ(key->GetType(), mojom::IDBKeyType::Array);
    EXPECT_EQ(key->Array().size(), 0UL);
  }

  {
    auto key = ScriptToKey(scope, "[0, 'abc']");
    EXPECT_EQ(key->GetType(), mojom::IDBKeyType::Array);

    const IDBKey::KeyArray& array = key->Array();
    EXPECT_EQ(array.size(), 2UL);
    EXPECT_EQ(array[0]->GetType(), mojom::IDBKeyType::Number);
    EXPECT_EQ(array[1]->GetType(), mojom::IDBKeyType::String);
  }
}

TEST(IDBKeyFromValue, NestedArray) {
  V8TestingScope scope;

  auto key = ScriptToKey(scope, "[0, ['xyz', Infinity], 'abc']");
  EXPECT_EQ(key->GetType(), mojom::IDBKeyType::Array);

  const IDBKey::KeyArray& array = key->Array();
  EXPECT_EQ(array.size(), 3UL);
  EXPECT_EQ(array[0]->GetType(), mojom::IDBKeyType::Number);
  EXPECT_EQ(array[1]->GetType(), mojom::IDBKeyType::Array);
  EXPECT_EQ(array[1]->Array().size(), 2UL);
  EXPECT_EQ(array[1]->Array()[0]->GetType(), mojom::IDBKeyType::String);
  EXPECT_EQ(array[1]->Array()[1]->GetType(), mojom::IDBKeyType::Number);
  EXPECT_EQ(array[2]->GetType(), mojom::IDBKeyType::String);
}

TEST(IDBKeyFromValue, CircularArray) {
  V8TestingScope scope;
  auto key = ScriptToKey(scope,
                         "(() => {"
                         "  const a = [];"
                         "  a.push(a);"
                         "  return a;"
                         "})()");
  EXPECT_FALSE(key->IsValid());
}

TEST(IDBKeyFromValue, DeepArray) {
  V8TestingScope scope;
  auto key = ScriptToKey(scope,
                         "(() => {"
                         "  let a = [];"
                         "  for (let i = 0; i < 10000; ++i) { a.push(a); }"
                         "  return a;"
                         "})()");
  EXPECT_FALSE(key->IsValid());
}

TEST(IDBKeyFromValue, SparseArray) {
  V8TestingScope scope;
  auto key = ScriptToKey(scope, "[,1]");
  EXPECT_FALSE(key->IsValid());

  // Ridiculously large sparse array - ensure we check before allocating.
  key = ScriptToKey(scope, "Object.assign([], {length: 2e9})");
  EXPECT_FALSE(key->IsValid());

  // Large sparse arrays as subkeys - ensure we check while recursing.
  key = ScriptToKey(scope, "[Object.assign([], {length: 2e9})]");
  EXPECT_FALSE(key->IsValid());
}

TEST(IDBKeyFromValue, ShrinkingArray) {
  V8TestingScope scope;
  auto key = ScriptToKey(
      scope,
      "(() => {"
      "  const a = [0, 1, 2];"
      "  Object.defineProperty(a, 1, {get: () => { a.length = 2; return 1; }});"
      "  return a;"
      "})()");
  EXPECT_FALSE(key->IsValid());
}

TEST(IDBKeyFromValue, Exceptions) {
  V8TestingScope scope;

  const char* cases[] = {
      // Detached ArrayBuffer.
      "(() => {"
      "  const a = new ArrayBuffer(3);"
      "  postMessage(a, '*', [a]);"
      "  return a;"
      "})()",

      // Detached ArrayBuffer view.
      "(() => {"
      "  const a = new Uint8Array([0,1,2]);"
      "  postMessage(a.buffer, '*', [a.buffer]);"
      "  return a;"
      "})()",

      // Value is an array with a getter that throws.
      "(()=>{"
      "  const a = [0, 1, 2];"
      "  Object.defineProperty(a, 1, {get: () => { throw Error(); }});"
      "  return a;"
      "})()",

      // Value is an array containing an array with a getter that throws.
      "(()=>{"
      "  const a = [0, 1, 2];"
      "  Object.defineProperty(a, 1, {get: () => { throw Error(); }});"
      "  return ['x', a, 'z'];"
      "})()",

      // Array with unconvertable item
      "(() => {"
      "  const a = new ArrayBuffer(3);"
      "  postMessage(a, '*', [a]);"
      "  return [a];"
      "})()",
  };

  for (const char* source : cases) {
    ScriptValue script_value(scope.GetIsolate(),
                             EvaluateScriptAsObject(scope, source));

    DummyExceptionStateForTesting exception_state;
    auto key = ScriptValue::To<std::unique_ptr<IDBKey>>(
        scope.GetIsolate(), script_value, exception_state);
    EXPECT_FALSE(key->IsValid());
    EXPECT_TRUE(exception_state.HadException());
  }
}

TEST(IDBKeyFromValueAndKeyPathTest, Exceptions) {
  V8TestingScope scope;
  ScriptValue script_value(
      scope.GetIsolate(),
      EvaluateScriptAsObject(scope,
                             "({id:1, get throws() { throw Error(); }})"));
  {
    // Key path references a property that throws.
    DummyExceptionStateForTesting exception_state;
    EXPECT_FALSE(ScriptValue::To<std::unique_ptr<IDBKey>>(
        scope.GetIsolate(), script_value, exception_state,
        IDBKeyPath("throws")));
    EXPECT_TRUE(exception_state.HadException());
  }

  {
    // Compound key path references a property that throws.
    DummyExceptionStateForTesting exception_state;
    EXPECT_FALSE(ScriptValue::To<std::unique_ptr<IDBKey>>(
        scope.GetIsolate(), script_value, exception_state,
        IDBKeyPath(Vector<String>{"id", "throws"})));
    EXPECT_TRUE(exception_state.HadException());
  }

  {
    // Compound key path references a property that throws, index case.
    DummyExceptionStateForTesting exception_state;
    EXPECT_FALSE(ScriptValue::To<std::unique_ptr<IDBKey>>(
        scope.GetIsolate(), script_value, exception_state,
        /*store_key_path=*/IDBKeyPath("id"),
        /*index_key_path=*/IDBKeyPath(Vector<String>{"id", "throws"})));
    EXPECT_TRUE(exception_state.HadException());
  }
}

TEST(IDBKeyFromValueAndKeyPathsTest, IndexKeys) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  v8::Isolate* isolate = scope.GetIsolate();
  NonThrowableExceptionState exception_state;

  // object = { foo: { bar: "zee" }, bad: null }
  ScriptValue script_value =
      V8ObjectBuilder(script_state)
          .Add("foo", V8ObjectBuilder(script_state).Add("bar", "zee"))
          .AddNull("bad")
          .GetScriptValue();

  // Index key path member matches store key path.
  std::unique_ptr<IDBKey> key = ScriptValue::To<std::unique_ptr<IDBKey>>(
      isolate, script_value, exception_state,
      /*store_key_path=*/IDBKeyPath("id"),
      /*index_key_path=*/IDBKeyPath(Vector<String>{"id", "foo.bar"}));
  IDBKey::KeyArray expected;
  expected.emplace_back(IDBKey::CreateNone());
  expected.emplace_back(IDBKey::CreateString("zee"));
  CheckArrayKey(key.get(), expected);

  // Index key path member matches, but there are unmatched members too.
  EXPECT_FALSE(ScriptValue::To<std::unique_ptr<IDBKey>>(
      isolate, script_value, exception_state,
      /*store_key_path=*/IDBKeyPath("id"),
      /*index_key_path=*/IDBKeyPath(Vector<String>{"id", "foo.bar", "nope"})));

  // Index key path member matches, but there are invalid subkeys too.
  EXPECT_FALSE(
      ScriptValue::To<std::unique_ptr<IDBKey>>(
          isolate, script_value, exception_state,
          /*store_key_path=*/IDBKeyPath("id"),
          /*index_key_path=*/IDBKeyPath(Vector<String>{"id", "foo.bar", "bad"}))
          ->IsValid());

  // Index key path member does not match store key path.
  EXPECT_FALSE(ScriptValue::To<std::unique_ptr<IDBKey>>(
      isolate, script_value, exception_state,
      /*store_key_path=*/IDBKeyPath("id"),
      /*index_key_path=*/IDBKeyPath(Vector<String>{"id2", "foo.bar"})));

  // Index key path is not array, matches store key path.
  EXPECT_FALSE(ScriptValue::To<std::unique_ptr<IDBKey>>(
      isolate, script_value, exception_state,
      /*store_key_path=*/IDBKeyPath("id"),
      /*index_key_path=*/IDBKeyPath("id")));
}

TEST(InjectIDBKeyTest, ImplicitValues) {
  V8TestingScope scope;
  v8::Isolate* isolate = scope.GetIsolate();
  {
    v8::Local<v8::String> string = V8String(isolate, "string");
    ScriptValue value = ScriptValue(scope.GetIsolate(), string);
    std::unique_ptr<IDBKey> idb_key = IDBKey::CreateNumber(123);
    CheckInjectionIgnored(scope.GetScriptState(), idb_key.get(), value,
                          "length");
  }
  {
    v8::Local<v8::Array> array = v8::Array::New(isolate);
    ScriptValue value = ScriptValue(scope.GetIsolate(), array);
    std::unique_ptr<IDBKey> idb_key = IDBKey::CreateNumber(456);
    CheckInjectionIgnored(scope.GetScriptState(), idb_key.get(), value,
                          "length");
  }
}

TEST(InjectIDBKeyTest, TopLevelPropertyStringValue) {
  V8TestingScope scope;

  // object = { foo: "zoo" }
  ScriptValue script_object = V8ObjectBuilder(scope.GetScriptState())
                                  .Add("foo", "zoo")
                                  .GetScriptValue();
  std::unique_ptr<IDBKey> idb_string_key = IDBKey::CreateString("myNewKey");
  CheckInjection(scope.GetScriptState(), idb_string_key.get(), script_object,
                 "bar");
  std::unique_ptr<IDBKey> idb_number_key = IDBKey::CreateNumber(1234);
  CheckInjection(scope.GetScriptState(), idb_number_key.get(), script_object,
                 "bar");

  CheckInjectionDisallowed(scope.GetScriptState(), script_object, "foo.bar");
}

TEST(InjectIDBKeyTest, SubProperty) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();

  // object = { foo: { bar: "zee" } }
  ScriptValue script_object =
      V8ObjectBuilder(script_state)
          .Add("foo", V8ObjectBuilder(script_state).Add("bar", "zee"))
          .GetScriptValue();

  std::unique_ptr<IDBKey> idb_string_key = IDBKey::CreateString("myNewKey");
  CheckInjection(scope.GetScriptState(), idb_string_key.get(), script_object,
                 "foo.baz");
  std::unique_ptr<IDBKey> idb_number_key = IDBKey::CreateNumber(789);
  CheckInjection(scope.GetScriptState(), idb_number_key.get(), script_object,
                 "foo.baz");
  std::unique_ptr<IDBKey> idb_date_key = IDBKey::CreateDate(4567);
  CheckInjection(scope.GetScriptState(), idb_date_key.get(), script_object,
                 "foo.baz");
  CheckInjection(scope.GetScriptState(), idb_date_key.get(), script_object,
                 "bar");
  std::unique_ptr<IDBKey> idb_array_key =
      IDBKey::CreateArray(IDBKey::KeyArray());
  CheckInjection(scope.GetScriptState(), idb_array_key.get(), script_object,
                 "foo.baz");
  CheckInjection(scope.GetScriptState(), idb_array_key.get(), script_object,
                 "bar");

  CheckInjectionDisallowed(scope.GetScriptState(), script_object,
                           "foo.bar.baz");
  std::unique_ptr<IDBKey> idb_zoo_key = IDBKey::CreateString("zoo");
  CheckInjection(scope.GetScriptState(), idb_zoo_key.get(), script_object,
                 "foo.xyz.foo");
}

TEST(DeserializeIDBValueTest, CurrentVersions) {
  V8TestingScope scope;
  v8::Isolate* isolate = scope.GetIsolate();

  Vector<char> object_bytes;
  v8::Local<v8::Object> empty_object = v8::Object::New(isolate);
  SerializeV8Value(empty_object, isolate, &object_bytes);
  std::unique_ptr<IDBValue> idb_value =
      CreateIDBValue(isolate, object_bytes, 42.0, "foo");

  v8::Local<v8::Value> v8_value = DeserializeIDBValue(
      isolate, scope.GetContext()->Global(), idb_value.get());
  EXPECT_TRUE(!scope.GetExceptionState().HadException());

  ASSERT_TRUE(v8_value->IsObject());
  v8::Local<v8::Object> v8_value_object = v8_value.As<v8::Object>();
  v8::Local<v8::Value> v8_number_value =
      v8_value_object->Get(scope.GetContext(), V8AtomicString(isolate, "foo"))
          .ToLocalChecked();
  ASSERT_TRUE(v8_number_value->IsNumber());
  v8::Local<v8::Number> v8_number = v8_number_value.As<v8::Number>();
  EXPECT_EQ(v8_number->Value(), 42.0);
}

TEST(DeserializeIDBValueTest, FutureV8Version) {
  V8TestingScope scope;
  v8::Isolate* isolate = scope.GetIsolate();

  // Pretend that the object was serialized by a future version of V8.
  Vector<char> object_bytes;
  v8::Local<v8::Object> empty_object = v8::Object::New(isolate);
  SerializeV8Value(empty_object, isolate, &object_bytes);
  object_bytes[kSSVHeaderV8VersionTagOffset] += 1;

  // The call sequence below mimics IndexedDB's usage pattern when attempting to
  // read a value in an object store with a key generator and a key path, but
  // the serialized value uses a newer format version.
  //
  // http://crbug.com/703704 has a reproduction for this test's circumstances.
  std::unique_ptr<IDBValue> idb_value =
      CreateIDBValue(isolate, object_bytes, 42.0, "foo");

  v8::Local<v8::Value> v8_value = DeserializeIDBValue(
      isolate, scope.GetContext()->Global(), idb_value.get());
  EXPECT_TRUE(!scope.GetExceptionState().HadException());
  EXPECT_TRUE(v8_value->IsNull());
}

TEST(DeserializeIDBValueTest, InjectionIntoNonObject) {
  V8TestingScope scope;
  v8::Isolate* isolate = scope.GetIsolate();

  // Simulate a storage corruption where an object is read back as a number.
  // This test uses a one-segment key path.
  Vector<char> object_bytes;
  v8::Local<v8::Number> number = v8::Number::New(isolate, 42.0);
  SerializeV8Value(number, isolate, &object_bytes);
  std::unique_ptr<IDBValue> idb_value =
      CreateIDBValue(isolate, object_bytes, 42.0, "foo");

  v8::Local<v8::Value> v8_value = DeserializeIDBValue(
      isolate, scope.GetContext()->Global(), idb_value.get());
  EXPECT_TRUE(!scope.GetExceptionState().HadException());
  ASSERT_TRUE(v8_value->IsNumber());
  v8::Local<v8::Number> v8_number = v8_value.As<v8::Number>();
  EXPECT_EQ(v8_number->Value(), 42.0);
}

TEST(DeserializeIDBValueTest, NestedInjectionIntoNonObject) {
  V8TestingScope scope;
  v8::Isolate* isolate = scope.GetIsolate();

  // Simulate a storage corruption where an object is read back as a number.
  // This test uses a multiple-segment key path.
  Vector<char> object_bytes;
  v8::Local<v8::Number> number = v8::Number::New(isolate, 42.0);
  SerializeV8Value(number, isolate, &object_bytes);
  std::unique_ptr<IDBValue> idb_value =
      CreateIDBValue(isolate, object_bytes, 42.0, "foo.bar");

  v8::Local<v8::Value> v8_value = DeserializeIDBValue(
      isolate, scope.GetContext()->Global(), idb_value.get());
  EXPECT_TRUE(!scope.GetExceptionState().HadException());
  ASSERT_TRUE(v8_value->IsNumber());
  v8::Local<v8::Number> v8_number = v8_value.As<v8::Number>();
  EXPECT_EQ(v8_number->Value(), 42.0);
}

}  // namespace blink