static v8::Handle<v8::Value> boundCallback(const v8::Arguments& args)
{
INC_STATS("DOM.IDBKeyRange.bound");
if (args.Length() < 2)
return throwError("Not enough arguments", V8Proxy::TypeError);
ExceptionCode ec = 0;
{
RefPtr<IDBKey> lower = createIDBKeyFromValue(args[0]);
if (UNLIKELY(!lower)) {
ec = TYPE_MISMATCH_ERR;
goto fail;
}
RefPtr<IDBKey> upper = createIDBKeyFromValue(args[1]);
if (UNLIKELY(!upper)) {
ec = TYPE_MISMATCH_ERR;
goto fail;
}
if (args.Length() <= 2) {
return toV8(IDBKeyRange::bound(lower, upper));
}
EXCEPTION_BLOCK(bool, lowerOpen, MAYBE_MISSING_PARAMETER(args, 2, MissingIsUndefined)->BooleanValue());
if (args.Length() <= 3) {
return toV8(IDBKeyRange::bound(lower, upper, lowerOpen));
}
EXCEPTION_BLOCK(bool, upperOpen, MAYBE_MISSING_PARAMETER(args, 3, MissingIsUndefined)->BooleanValue());
return toV8(IDBKeyRange::bound(lower, upper, lowerOpen, upperOpen));
}
fail:
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
static PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value, Vector<v8::Handle<v8::Array> >& stack, v8::Isolate* isolate)
{
if (value->IsNumber() && !std::isnan(value->NumberValue()))
return IDBKey::createNumber(value->NumberValue());
if (value->IsString())
return IDBKey::createString(toCoreString(value.As<v8::String>()));
if (value->IsDate() && !std::isnan(value->NumberValue()))
return IDBKey::createDate(value->NumberValue());
if (value->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
if (stack.contains(array))
return 0;
if (stack.size() >= maximumDepth)
return 0;
stack.append(array);
IDBKey::KeyArray subkeys;
uint32_t length = array->Length();
for (uint32_t i = 0; i < length; ++i) {
v8::Local<v8::Value> item = array->Get(v8::Int32::New(i, isolate));
RefPtr<IDBKey> subkey = createIDBKeyFromValue(item, stack, isolate);
if (!subkey)
subkeys.append(IDBKey::createInvalid());
else
subkeys.append(subkey);
}
stack.removeLast();
return IDBKey::createArray(subkeys);
}
return 0;
}
IDBKey* scriptValueToIDBKey(v8::Isolate* isolate, const ScriptValue& scriptValue)
{
ASSERT(isolate->InContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Value> v8Value(scriptValue.v8Value());
return createIDBKeyFromValue(isolate, v8Value);
}
static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate, v8::Handle<v8::Value> value, bool allowExperimentalTypes = false)
{
Vector<v8::Handle<v8::Array> > stack;
if (IDBKey* key = createIDBKeyFromValue(isolate, value, stack, allowExperimentalTypes))
return key;
return IDBKey::createInvalid();
}
EncodedJSValue JSC_HOST_CALL jsIDBCursorPrototypeFunctionContinue(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&JSIDBCursor::s_info))
return throwVMTypeError(exec);
JSIDBCursor* castedThis = static_cast<JSIDBCursor*>(asObject(thisValue));
ASSERT_GC_OBJECT_INHERITS(castedThis, &JSIDBCursor::s_info);
IDBCursor* imp = static_cast<IDBCursor*>(castedThis->impl());
ExceptionCode ec = 0;
size_t argsCount = exec->argumentCount();
if (argsCount <= 0) {
imp->continueFunction(ec);
setDOMException(exec, ec);
return JSValue::encode(jsUndefined());
}
RefPtr<IDBKey> key(createIDBKeyFromValue(exec, exec->argument(0)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
imp->continueFunction(key, ec);
setDOMException(exec, ec);
return JSValue::encode(jsUndefined());
}
PassRefPtr<IDBKey> scriptValueToIDBKey(DOMRequestState* state, const ScriptValue& scriptValue)
{
v8::Isolate* isolate = state ? state->context()->GetIsolate() : v8::Isolate::GetCurrent();
ASSERT(isolate->InContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Value> v8Value(scriptValue.v8Value());
return createIDBKeyFromValue(v8Value, isolate);
}
static PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value, v8::Isolate* isolate)
{
Vector<v8::Handle<v8::Array> > stack;
RefPtr<IDBKey> key = createIDBKeyFromValue(value, stack, isolate);
if (key)
return key;
return IDBKey::createInvalid();
}
static RefPtr<IDBKey> createIDBKeyFromValue(ExecState* exec, JSValue value)
{
Vector<JSArray*> stack;
RefPtr<IDBKey> key = createIDBKeyFromValue(exec, value, stack);
if (key)
return key;
return IDBKey::createInvalid();
}
PassRefPtr<IDBKey> createIDBKeyFromSerializedValueAndKeyPath(PassRefPtr<SerializedScriptValue> value, const Vector<IDBKeyPathElement>& keyPath)
{
LocalContext localContext;
v8::Handle<v8::Value> v8Value(value->deserialize());
v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(v8Value, keyPath, keyPath.size()));
if (v8Key.IsEmpty())
return 0;
return createIDBKeyFromValue(v8Key);
}
static RefPtr<IDBKey> internalCreateIDBKeyFromScriptValueAndKeyPath(ExecState* exec, const JSC::JSValue& value, const String& keyPath)
{
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath, keyPathElements, error);
ASSERT(error == IDBKeyPathParseError::None);
JSValue jsValue = value;
jsValue = getNthValueOnKeyPath(exec, jsValue, keyPathElements, keyPathElements.size());
if (jsValue.isUndefined())
return nullptr;
return createIDBKeyFromValue(exec, jsValue);
}
static PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(const ScriptValue& value, const String& keyPath, v8::Isolate* isolate)
{
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath, keyPathElements, error);
ASSERT(error == IDBKeyPathParseErrorNone);
ASSERT(isolate->InContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Value> v8Value(value.v8Value());
v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size(), isolate));
if (v8Key.IsEmpty())
return 0;
return createIDBKeyFromValue(v8Key, isolate);
}
static IDBKey* createIDBKeyFromScriptValueAndKeyPathInternal(v8::Isolate* isolate, const ScriptValue& value, const String& keyPath, bool allowExperimentalTypes)
{
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath, keyPathElements, error);
ASSERT(error == IDBKeyPathParseErrorNone);
ASSERT(isolate->InContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Value> v8Value(value.v8Value());
v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(isolate, v8Value, keyPathElements, keyPathElements.size()));
if (v8Key.IsEmpty())
return 0;
return createIDBKeyFromValue(isolate, v8Key, allowExperimentalTypes);
}
static PassRefPtr<IDBKey> createIDBKeyFromSerializedValueAndKeyPath(PassRefPtr<SerializedScriptValue> prpValue, const String& keyPath)
{
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath, keyPathElements, error);
ASSERT(error == IDBKeyPathParseErrorNone);
RefPtr<SerializedScriptValue> value = prpValue;
V8AuxiliaryContext context;
v8::Handle<v8::Value> v8Value(value->deserialize());
v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size()));
if (v8Key.IsEmpty())
return 0;
return createIDBKeyFromValue(v8Key);
}
static v8::Handle<v8::Value> onlyCallback(const v8::Arguments& args)
{
INC_STATS("DOM.IDBKeyRange.only");
if (args.Length() < 1)
return throwError("Not enough arguments", V8Proxy::TypeError);
ExceptionCode ec = 0;
{
RefPtr<IDBKey> value = createIDBKeyFromValue(args[0]);
if (UNLIKELY(!value)) {
ec = TYPE_MISMATCH_ERR;
goto fail;
}
return toV8(IDBKeyRange::only(value));
}
fail:
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
PassRefPtr<IDBKey> createIDBKeyFromSerializedValueAndKeyPath(PassRefPtr<SerializedScriptValue> value, const Vector<IDBKeyPathElement>& keyPath)
{
LocalContext localContext;
v8::Handle<v8::Value> v8Value(value->deserialize());
for (size_t i = 0; i < keyPath.size(); ++i) {
switch (keyPath[i].type) {
case IDBKeyPathElement::IsIndexed:
if (!v8Value->IsArray() || !getValueFrom(keyPath[i].index, v8Value))
return 0;
break;
case IDBKeyPathElement::IsNamed:
if (!v8Value->IsObject() || !getValueFrom(v8String(keyPath[i].identifier), v8Value))
return 0;
break;
default:
ASSERT_NOT_REACHED();
}
}
return createIDBKeyFromValue(v8Value);
}
static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate, v8::Handle<v8::Value> value, Vector<v8::Handle<v8::Array> >& stack, bool allowExperimentalTypes = false)
{
if (value->IsNumber() && !std::isnan(value->NumberValue()))
return IDBKey::createNumber(value->NumberValue());
if (value->IsString())
return IDBKey::createString(toCoreString(value.As<v8::String>()));
if (value->IsDate() && !std::isnan(value->NumberValue()))
return IDBKey::createDate(value->NumberValue());
if (value->IsUint8Array() && (allowExperimentalTypes || RuntimeEnabledFeatures::indexedDBExperimentalEnabled())) {
// Per discussion in https://www.w3.org/Bugs/Public/show_bug.cgi?id=23332 the
// input type is constrained to Uint8Array to match the output type.
ArrayBufferView* view = blink::V8ArrayBufferView::toImpl(value->ToObject());
const char* start = static_cast<const char*>(view->baseAddress());
size_t length = view->byteLength();
return IDBKey::createBinary(SharedBuffer::create(start, length));
}
if (value->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
if (stack.contains(array))
return 0;
if (stack.size() >= maximumDepth)
return 0;
stack.append(array);
IDBKey::KeyArray subkeys;
uint32_t length = array->Length();
for (uint32_t i = 0; i < length; ++i) {
v8::Local<v8::Value> item = array->Get(v8::Int32::New(isolate, i));
IDBKey* subkey = createIDBKeyFromValue(isolate, item, stack, allowExperimentalTypes);
if (!subkey)
subkeys.append(IDBKey::createInvalid());
else
subkeys.append(subkey);
}
stack.removeLast();
return IDBKey::createArray(subkeys);
}
return 0;
}
EncodedJSValue JSC_HOST_CALL jsIDBIndexPrototypeFunctionGetKey(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&JSIDBIndex::s_info))
return throwVMTypeError(exec);
JSIDBIndex* castedThis = static_cast<JSIDBIndex*>(asObject(thisValue));
ASSERT_GC_OBJECT_INHERITS(castedThis, &JSIDBIndex::s_info);
IDBIndex* imp = static_cast<IDBIndex*>(castedThis->impl());
ExceptionCode ec = 0;
ScriptExecutionContext* scriptContext = static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
if (!scriptContext)
return JSValue::encode(jsUndefined());
RefPtr<IDBKey> key(createIDBKeyFromValue(exec, exec->argument(0)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->getKey(scriptContext, key, ec)));
setDOMException(exec, ec);
return JSValue::encode(result);
}
static RefPtr<IDBKey> createIDBKeyFromValue(ExecState* exec, JSValue value, Vector<JSArray*>& stack)
{
if (value.isNumber() && !std::isnan(value.toNumber(exec)))
return IDBKey::createNumber(value.toNumber(exec));
if (value.isString())
return IDBKey::createString(value.toString(exec)->value(exec));
if (value.inherits(DateInstance::info()) && !std::isnan(valueToDate(exec, value)))
return IDBKey::createDate(valueToDate(exec, value));
if (value.isObject()) {
JSObject* object = asObject(value);
if (isJSArray(object) || object->inherits(JSArray::info())) {
JSArray* array = asArray(object);
size_t length = array->length();
if (stack.contains(array))
return nullptr;
if (stack.size() >= maximumDepth)
return nullptr;
stack.append(array);
Vector<RefPtr<IDBKey>> subkeys;
for (size_t i = 0; i < length; i++) {
JSValue item = array->getIndex(exec, i);
RefPtr<IDBKey> subkey = createIDBKeyFromValue(exec, item, stack);
if (!subkey)
subkeys.append(IDBKey::createInvalid());
else
subkeys.append(subkey);
}
stack.removeLast();
return IDBKey::createArray(subkeys);
}
}
return nullptr;
}
RefPtr<IDBKey> scriptValueToIDBKey(ExecState& exec, const JSC::JSValue& scriptValue)
{
return createIDBKeyFromValue(&exec, scriptValue);
}
RefPtr<IDBKey> scriptValueToIDBKey(DOMRequestState* requestState, const JSC::JSValue& scriptValue)
{
ExecState* exec = requestState->exec();
return createIDBKeyFromValue(exec, scriptValue);
}
RefPtr<IDBKey> scriptValueToIDBKey(DOMRequestState* requestState, const Deprecated::ScriptValue& scriptValue)
{
ExecState* exec = requestState->exec();
return createIDBKeyFromValue(exec, scriptValue.jsValue());
}
