Vector<char> encodeIDBKeyPath(const IDBKeyPath& keyPath)
{
// May be typed, or may be a raw string. An invalid leading
// byte is used to identify typed coding. New records are
// always written as typed.
Vector<char> ret;
ret.append(IDBKeyPathTypeCodedByte1);
ret.append(IDBKeyPathTypeCodedByte2);
ret.append(static_cast<char>(keyPath.type()));
switch (keyPath.type()) {
case IDBKeyPath::NullType:
break;
case IDBKeyPath::StringType:
ret.append(encodeStringWithLength(keyPath.string()));
break;
case IDBKeyPath::ArrayType: {
const Vector<String>& array = keyPath.array();
size_t count = array.size();
ret.append(encodeVarInt(count));
for (size_t i = 0; i < count; ++i)
ret.append(encodeStringWithLength(array[i]));
break;
}
}
return ret;
}
static PassRefPtr<KeyPath> keyPathFromIDBKeyPath(const IDBKeyPath& idbKeyPath)
{
RefPtr<KeyPath> keyPath;
switch (idbKeyPath.type()) {
case IDBKeyPath::NullType:
keyPath = KeyPath::create().setType(KeyPath::Type::Null);
break;
case IDBKeyPath::StringType:
keyPath = KeyPath::create().setType(KeyPath::Type::String);
keyPath->setString(idbKeyPath.string());
break;
case IDBKeyPath::ArrayType: {
keyPath = KeyPath::create().setType(KeyPath::Type::Array);
RefPtr<TypeBuilder::Array<String> > array = TypeBuilder::Array<String>::create();
const Vector<String>& stringArray = idbKeyPath.array();
for (size_t i = 0; i < stringArray.size(); ++i)
array->addItem(stringArray[i]);
keyPath->setArray(array);
break;
}
default:
ASSERT_NOT_REACHED();
}
return keyPath.release();
}
static v8::Handle<v8::Value> toV8(const IDBKeyPath& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
switch (value.type()) {
case IDBKeyPath::NullType:
return v8::Null(isolate);
case IDBKeyPath::StringType:
return v8String(isolate, value.string());
case IDBKeyPath::ArrayType:
RefPtr<DOMStringList> keyPaths = DOMStringList::create();
for (Vector<String>::const_iterator it = value.array().begin(); it != value.array().end(); ++it)
keyPaths->append(*it);
return toV8(keyPaths.release(), creationContext, isolate);
}
ASSERT_NOT_REACHED();
return v8::Undefined(isolate);
}
static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const IDBKeyPath& value)
{
switch (value.type()) {
case IDBKeyPath::NullType:
return jsNull();
case IDBKeyPath::StringType:
return jsStringWithCache(exec, value.string());
case IDBKeyPath::ArrayType:
RefPtr<DOMStringList> keyPaths = DOMStringList::create();
for (Vector<String>::const_iterator it = value.array().begin(); it != value.array().end(); ++it)
keyPaths->append(*it);
return toJS(exec, globalObject, keyPaths.release());
}
ASSERT_NOT_REACHED();
return jsUndefined();
}
void ArgumentCoder<IDBKeyPath>::encode(ArgumentEncoder& encoder, const IDBKeyPath& keyPath)
{
encoder.encodeEnum(keyPath.type());
switch (keyPath.type()) {
case IDBKeyPath::NullType:
break;
case IDBKeyPath::StringType:
encoder << keyPath.string();
break;
case IDBKeyPath::ArrayType:
encoder << keyPath.array();
break;
default:
ASSERT_NOT_REACHED();
}
}
RefPtr<IDBKey> maybeCreateIDBKeyFromScriptValueAndKeyPath(ExecState& exec, const Deprecated::ScriptValue& value, const IDBKeyPath& keyPath)
{
ASSERT(!keyPath.isNull());
if (keyPath.type() == IndexedDB::KeyPathType::Array) {
Vector<RefPtr<IDBKey>> result;
const Vector<String>& array = keyPath.array();
for (size_t i = 0; i < array.size(); i++) {
RefPtr<IDBKey> key = internalCreateIDBKeyFromScriptValueAndKeyPath(&exec, value, array[i]);
if (!key)
return nullptr;
result.append(key);
}
return IDBKey::createArray(result);
}
ASSERT(keyPath.type() == IndexedDB::KeyPathType::String);
return internalCreateIDBKeyFromScriptValueAndKeyPath(&exec, value, keyPath.string());
}
RefPtr<IDBKey> maybeCreateIDBKeyFromScriptValueAndKeyPath(ExecState& exec, const JSC::JSValue& value, const IDBKeyPath& keyPath)
{
ASSERT(!keyPath.isNull());
if (keyPath.type() == IndexedDB::KeyPathType::Array) {
const Vector<String>& array = keyPath.array();
Vector<RefPtr<IDBKey>> result;
result.reserveInitialCapacity(array.size());
for (auto& string : array) {
RefPtr<IDBKey> key = internalCreateIDBKeyFromScriptValueAndKeyPath(&exec, value, string);
if (!key)
return nullptr;
result.uncheckedAppend(WTFMove(key));
}
return IDBKey::createArray(WTFMove(result));
}
ASSERT(keyPath.type() == IndexedDB::KeyPathType::String);
return internalCreateIDBKeyFromScriptValueAndKeyPath(&exec, value, keyPath.string());
}
RefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(ExecState* exec, const Deprecated::ScriptValue& value, const IDBKeyPath& keyPath)
{
LOG(StorageAPI, "createIDBKeyFromScriptValueAndKeyPath");
ASSERT(!keyPath.isNull());
if (keyPath.type() == IDBKeyPath::ArrayType) {
Vector<RefPtr<IDBKey>> result;
const Vector<String>& array = keyPath.array();
for (size_t i = 0; i < array.size(); i++) {
RefPtr<IDBKey> key = internalCreateIDBKeyFromScriptValueAndKeyPath(exec, value, array[i]);
if (!key)
return nullptr;
result.append(key);
}
return IDBKey::createArray(result);
}
ASSERT(keyPath.type() == IDBKeyPath::StringType);
return internalCreateIDBKeyFromScriptValueAndKeyPath(exec, value, keyPath.string());
}
PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(DOMRequestState* state, const ScriptValue& value, const IDBKeyPath& keyPath)
{
IDB_TRACE("createIDBKeyFromScriptValueAndKeyPath");
ASSERT(!keyPath.isNull());
v8::Isolate* isolate = state ? state->context()->GetIsolate() : v8::Isolate::GetCurrent();
ASSERT(isolate->InContext());
v8::HandleScope handleScope(isolate);
if (keyPath.type() == IDBKeyPath::ArrayType) {
IDBKey::KeyArray result;
const Vector<String>& array = keyPath.array();
for (size_t i = 0; i < array.size(); ++i) {
RefPtr<IDBKey> key = createIDBKeyFromScriptValueAndKeyPath(value, array[i], isolate);
if (!key)
return 0;
result.append(key);
}
return IDBKey::createArray(result);
}
ASSERT(keyPath.type() == IDBKeyPath::StringType);
return createIDBKeyFromScriptValueAndKeyPath(value, keyPath.string(), isolate);
}
PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(DOMRequestState* requestState, const ScriptValue& value, const IDBKeyPath& keyPath)
{
IDB_TRACE("createIDBKeyFromScriptValueAndKeyPath");
ASSERT(!keyPath.isNull());
ExecState* exec = requestState->exec();
if (keyPath.type() == IDBKeyPath::ArrayType) {
IDBKey::KeyArray result;
const Vector<String>& array = keyPath.array();
for (size_t i = 0; i < array.size(); i++) {
RefPtr<IDBKey> key = createIDBKeyFromScriptValueAndKeyPath(exec, value, array[i]);
if (!key)
return 0;
result.append(key);
}
return IDBKey::createArray(result);
}
ASSERT(keyPath.type() == IDBKeyPath::StringType);
return createIDBKeyFromScriptValueAndKeyPath(exec, value, keyPath.string());
}
PassRefPtr<IDBKey> createIDBKeyFromSerializedValueAndKeyPath(PassRefPtr<SerializedScriptValue> prpValue, const IDBKeyPath& keyPath)
{
IDB_TRACE("createIDBKeyFromSerializedValueAndKeyPath");
ASSERT(!keyPath.isNull());
RefPtr<SerializedScriptValue> value = prpValue;
if (keyPath.type() == IDBKeyPath::ArrayType) {
IDBKey::KeyArray result;
const Vector<String>& array = keyPath.array();
for (size_t i = 0; i < array.size(); ++i) {
RefPtr<IDBKey> key = createIDBKeyFromSerializedValueAndKeyPath(value, array[i]);
if (!key)
return 0;
result.append(key);
}
return IDBKey::createArray(result);
}
ASSERT(keyPath.type() == IDBKeyPath::StringType);
return createIDBKeyFromSerializedValueAndKeyPath(value, keyPath.string());
}