void IDBCursor::continueFunction(ScriptState* scriptState, const ScriptValue& keyValue, ExceptionState& exceptionState)
{
IDB_TRACE("IDBCursor::continue");
IDBKey* key = keyValue.isUndefined() || keyValue.isNull() ? nullptr : scriptValueToIDBKey(scriptState->isolate(), keyValue);
if (key && !key->isValid()) {
exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return;
}
continueFunction(key, 0, exceptionState);
}
void IDBCursor::continueFunction(ExecutionContext* context, const ScriptValue& keyValue, ExceptionState& exceptionState)
{
IDB_TRACE("IDBCursor::continue");
RefPtrWillBeRawPtr<IDBKey> key = keyValue.isUndefined() || keyValue.isNull() ? nullptr : scriptValueToIDBKey(toIsolate(context), keyValue);
if (key && !key->isValid()) {
exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return;
}
continueFunction(key.release(), nullptr, exceptionState);
}
PassRefPtr<IDBKeyRange> IDBKeyRange::fromScriptValue(ExecutionContext* context, const ScriptValue& value, ExceptionState& es)
{
DOMRequestState requestState(context);
if (value.isUndefined() || value.isNull())
return 0;
RefPtr<IDBKeyRange> range = scriptValueToIDBKeyRange(&requestState, value);
if (range)
return range.release();
RefPtr<IDBKey> key = scriptValueToIDBKey(&requestState, value);
if (!key || !key->isValid()) {
es.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
return adoptRef(new IDBKeyRange(key, key, LowerBoundClosed, UpperBoundClosed));
}
PassRefPtrWillBeRawPtr<EffectModel> EffectInput::convert(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, ExceptionState& exceptionState)
{
if (!element)
return nullptr;
// TODO(alancutter): Remove this once composited animations no longer depend on AnimatableValues.
if (element->inActiveDocument())
element->document().updateLayoutTreeForNodeIfNeeded(element);
StyleSheetContents* styleSheetContents = element->document().elementSheet().contents();
StringKeyframeVector keyframes;
double lastOffset = 0;
for (const auto& keyframeDictionary : keyframeDictionaryVector) {
RefPtrWillBeRawPtr<StringKeyframe> keyframe = StringKeyframe::create();
ScriptValue scriptValue;
bool frameHasOffset = DictionaryHelper::get(keyframeDictionary, "offset", scriptValue) && !scriptValue.isNull();
if (frameHasOffset) {
double offset;
DictionaryHelper::get(keyframeDictionary, "offset", offset);
// Keyframes with offsets outside the range [0.0, 1.0] are an error.
if (std::isnan(offset)) {
exceptionState.throwDOMException(InvalidModificationError, "Non numeric offset provided");
}
if (offset < 0 || offset > 1) {
exceptionState.throwDOMException(InvalidModificationError, "Offsets provided outside the range [0, 1]");
return nullptr;
}
if (offset < lastOffset) {
exceptionState.throwDOMException(InvalidModificationError, "Keyframes with specified offsets are not sorted");
return nullptr;
}
lastOffset = offset;
keyframe->setOffset(offset);
}
keyframes.append(keyframe);
String compositeString;
DictionaryHelper::get(keyframeDictionary, "composite", compositeString);
if (compositeString == "add")
keyframe->setComposite(EffectModel::CompositeAdd);
String timingFunctionString;
if (DictionaryHelper::get(keyframeDictionary, "easing", timingFunctionString)) {
if (RefPtr<TimingFunction> timingFunction = AnimationInputHelpers::parseTimingFunction(timingFunctionString))
keyframe->setEasing(timingFunction);
}
Vector<String> keyframeProperties;
keyframeDictionary.getPropertyNames(keyframeProperties);
for (const auto& property : keyframeProperties) {
String value;
DictionaryHelper::get(keyframeDictionary, property, value);
CSSPropertyID id = AnimationInputHelpers::keyframeAttributeToCSSPropertyID(property);
if (id != CSSPropertyInvalid) {
keyframe->setPropertyValue(id, value, element, styleSheetContents);
continue;
}
if (property == "offset"
|| property == "composite"
|| property == "easing") {
continue;
}
if (!RuntimeEnabledFeatures::webAnimationsSVGEnabled() || !element->isSVGElement() || !svgPrefixed(property))
continue;
SVGElement* svgElement = toSVGElement(element);
const QualifiedName* qualifiedName = supportedSVGAttribute(property, svgElement);
if (qualifiedName)
keyframe->setPropertyValue(*qualifiedName, value, svgElement);
}
}
RefPtrWillBeRawPtr<StringKeyframeEffectModel> keyframeEffectModel = StringKeyframeEffectModel::create(keyframes);
if (keyframeEffectModel->hasSyntheticKeyframes()) {
exceptionState.throwDOMException(NotSupportedError, "Partial keyframes are not supported.");
return nullptr;
}
if (!keyframeEffectModel->isReplaceOnly()) {
exceptionState.throwDOMException(NotSupportedError, "Additive animations are not supported.");
return nullptr;
}
keyframeEffectModel->forceConversionsToAnimatableValues(*element, element->computedStyle());
return keyframeEffectModel;
}
PassRefPtrWillBeRawPtr<AnimationEffect> EffectInput::convert(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, ExceptionState& exceptionState)
{
// FIXME: Remove the dependency on element.
if (!element)
return nullptr;
StyleSheetContents* styleSheetContents = element->document().elementSheet().contents();
StringKeyframeVector keyframes;
double lastOffset = 0;
for (const auto& keyframeDictionary : keyframeDictionaryVector) {
RefPtrWillBeRawPtr<StringKeyframe> keyframe = StringKeyframe::create();
ScriptValue scriptValue;
bool frameHasOffset = DictionaryHelper::get(keyframeDictionary, "offset", scriptValue) && !scriptValue.isNull();
if (frameHasOffset) {
double offset;
DictionaryHelper::get(keyframeDictionary, "offset", offset);
// Keyframes with offsets outside the range [0.0, 1.0] are an error.
if (std::isnan(offset)) {
exceptionState.throwDOMException(InvalidModificationError, "Non numeric offset provided");
}
if (offset < 0 || offset > 1) {
exceptionState.throwDOMException(InvalidModificationError, "Offsets provided outside the range [0, 1]");
return nullptr;
}
if (offset < lastOffset) {
exceptionState.throwDOMException(InvalidModificationError, "Keyframes with specified offsets are not sorted");
return nullptr;
}
lastOffset = offset;
keyframe->setOffset(offset);
}
keyframes.append(keyframe);
String compositeString;
DictionaryHelper::get(keyframeDictionary, "composite", compositeString);
if (compositeString == "add")
keyframe->setComposite(AnimationEffect::CompositeAdd);
String timingFunctionString;
if (DictionaryHelper::get(keyframeDictionary, "easing", timingFunctionString)) {
if (RefPtr<TimingFunction> timingFunction = AnimationInputHelpers::parseTimingFunction(timingFunctionString))
keyframe->setEasing(timingFunction);
}
Vector<String> keyframeProperties;
keyframeDictionary.getPropertyNames(keyframeProperties);
for (const auto& property : keyframeProperties) {
CSSPropertyID id = AnimationInputHelpers::keyframeAttributeToCSSPropertyID(property);
if (id == CSSPropertyInvalid)
continue;
String value;
DictionaryHelper::get(keyframeDictionary, property, value);
keyframe->setPropertyValue(id, value, styleSheetContents);
}
}
RefPtrWillBeRawPtr<StringKeyframeEffectModel> keyframeEffectModel = StringKeyframeEffectModel::create(keyframes);
if (keyframeEffectModel->hasSyntheticKeyframes()) {
exceptionState.throwDOMException(NotSupportedError, "Partial keyframes are not supported.");
return nullptr;
}
if (!keyframeEffectModel->isReplaceOnly()) {
exceptionState.throwDOMException(NotSupportedError, "Additive animations are not supported.");
return nullptr;
}
keyframeEffectModel->forceConversionsToAnimatableValues(element);
return keyframeEffectModel;
}
PassRefPtrWillBeRawPtr<AnimationEffect> EffectInput::convert(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, ExceptionState& exceptionState)
{
// FIXME: Remove the dependency on element.
if (!element)
return nullptr;
StyleSheetContents* styleSheetContents = element->document().elementSheet().contents();
StringKeyframeVector keyframes;
double lastOffset = 0;
for (size_t i = 0; i < keyframeDictionaryVector.size(); ++i) {
RefPtrWillBeRawPtr<StringKeyframe> keyframe = StringKeyframe::create();
ScriptValue scriptValue;
bool frameHasOffset = DictionaryHelper::get(keyframeDictionaryVector[i], "offset", scriptValue) && !scriptValue.isNull();
if (frameHasOffset) {
double offset;
DictionaryHelper::get(keyframeDictionaryVector[i], "offset", offset);
// Keyframes with offsets outside the range [0.0, 1.0] are an error.
if (std::isnan(offset)) {
exceptionState.throwDOMException(InvalidModificationError, "Non numeric offset provided");
}
if (offset < 0 || offset > 1) {
exceptionState.throwDOMException(InvalidModificationError, "Offsets provided outside the range [0, 1]");
return nullptr;
}
if (offset < lastOffset) {
exceptionState.throwDOMException(InvalidModificationError, "Keyframes with specified offsets are not sorted");
return nullptr;
}
lastOffset = offset;
keyframe->setOffset(offset);
}
keyframes.append(keyframe);
String compositeString;
DictionaryHelper::get(keyframeDictionaryVector[i], "composite", compositeString);
if (compositeString == "add")
keyframe->setComposite(AnimationEffect::CompositeAdd);
String timingFunctionString;
if (DictionaryHelper::get(keyframeDictionaryVector[i], "easing", timingFunctionString)) {
if (RefPtrWillBeRawPtr<CSSValue> timingFunctionValue = BisonCSSParser::parseAnimationTimingFunctionValue(timingFunctionString))
keyframe->setEasing(CSSToStyleMap::mapAnimationTimingFunction(timingFunctionValue.get(), true));
}
Vector<String> keyframeProperties;
keyframeDictionaryVector[i].getOwnPropertyNames(keyframeProperties);
for (size_t j = 0; j < keyframeProperties.size(); ++j) {
String property = keyframeProperties[j];
CSSPropertyID id = camelCaseCSSPropertyNameToID(property);
if (id == CSSPropertyInvalid)
continue;
String value;
DictionaryHelper::get(keyframeDictionaryVector[i], property, value);
keyframe->setPropertyValue(id, value, styleSheetContents);
}
}
RefPtrWillBeRawPtr<StringKeyframeEffectModel> keyframeEffectModel = StringKeyframeEffectModel::create(keyframes);
if (!keyframeEffectModel->isReplaceOnly()) {
exceptionState.throwDOMException(NotSupportedError, "Partial keyframes are not supported.");
return nullptr;
}
keyframeEffectModel->forceConversionsToAnimatableValues(element);
return keyframeEffectModel;
}
bool CustomElementConstructorBuilder::validateOptions(const AtomicString& type, QualifiedName& tagName, ExceptionState& exceptionState)
{
ASSERT(m_prototype.IsEmpty());
v8::TryCatch tryCatch;
ScriptValue prototypeScriptValue;
if (m_options->get("prototype", prototypeScriptValue) && !prototypeScriptValue.isNull()) {
ASSERT(!tryCatch.HasCaught());
if (!prototypeScriptValue.isObject()) {
CustomElementException::throwException(CustomElementException::PrototypeNotAnObject, type, exceptionState);
tryCatch.ReThrow();
return false;
}
m_prototype = prototypeScriptValue.v8Value().As<v8::Object>();
} else if (!tryCatch.HasCaught()) {
m_prototype = v8::Object::New(m_scriptState->isolate());
v8::Local<v8::Object> basePrototype = m_scriptState->perContextData()->prototypeForType(&V8HTMLElement::wrapperTypeInfo);
if (!basePrototype.IsEmpty())
m_prototype->SetPrototype(basePrototype);
}
if (tryCatch.HasCaught()) {
tryCatch.ReThrow();
return false;
}
AtomicString extends;
bool extendsProvidedAndNonNull = m_options->get("extends", extends);
if (tryCatch.HasCaught()) {
tryCatch.ReThrow();
return false;
}
if (!m_scriptState->perContextData()) {
// FIXME: This should generate an InvalidContext exception at a later point.
CustomElementException::throwException(CustomElementException::ContextDestroyedCheckingPrototype, type, exceptionState);
tryCatch.ReThrow();
return false;
}
AtomicString namespaceURI = HTMLNames::xhtmlNamespaceURI;
if (hasValidPrototypeChainFor(&V8SVGElement::wrapperTypeInfo))
namespaceURI = SVGNames::svgNamespaceURI;
ASSERT(!tryCatch.HasCaught());
AtomicString localName;
if (extendsProvidedAndNonNull) {
localName = extends.lower();
if (!Document::isValidName(localName)) {
CustomElementException::throwException(CustomElementException::ExtendsIsInvalidName, type, exceptionState);
tryCatch.ReThrow();
return false;
}
if (CustomElement::isValidName(localName)) {
CustomElementException::throwException(CustomElementException::ExtendsIsCustomElementName, type, exceptionState);
tryCatch.ReThrow();
return false;
}
} else {
if (namespaceURI == SVGNames::svgNamespaceURI) {
CustomElementException::throwException(CustomElementException::ExtendsIsInvalidName, type, exceptionState);
tryCatch.ReThrow();
return false;
}
localName = type;
}
if (!extendsProvidedAndNonNull)
m_wrapperType = &V8HTMLElement::wrapperTypeInfo;
else if (namespaceURI == HTMLNames::xhtmlNamespaceURI)
m_wrapperType = findWrapperTypeForHTMLTagName(localName);
else
m_wrapperType = findWrapperTypeForSVGTagName(localName);
ASSERT(!tryCatch.HasCaught());
ASSERT(m_wrapperType);
tagName = QualifiedName(nullAtom, localName, namespaceURI);
return m_wrapperType;
}