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()); }