PassRefPtr<Element> CustomElementRegistry::createCustomTagElement(const QualifiedName& tagName)
{
if (!document())
return 0;
ASSERT(isCustomTagName(tagName.localName()));
RefPtr<Element> element;
if (HTMLNames::xhtmlNamespaceURI == tagName.namespaceURI())
element = HTMLElement::create(tagName, document());
else if (SVGNames::svgNamespaceURI == tagName.namespaceURI())
element = SVGElement::create(tagName, document());
else
return Element::create(tagName, document());
element->setIsCustomElement();
RefPtr<CustomElementDefinition> definition = findAndCheckNamespace(tagName.localName(), tagName.namespaceURI());
if (!definition || definition->isTypeExtension()) {
// If a definition for a type extension was available, this
// custom tag element will be unresolved in perpetuity.
didCreateUnresolvedElement(CustomElementDefinition::CustomTag, tagName.localName(), element.get());
} else {
didCreateCustomTagElement(definition.get(), element.get());
}
return element.release();
}
void CustomElementRegistry::registerElement(CustomElementConstructorBuilder* constructorBuilder, const AtomicString& userSuppliedName, ExceptionCode& ec)
{
RefPtr<CustomElementRegistry> protect(this);
if (!constructorBuilder->isFeatureAllowed())
return;
AtomicString type = userSuppliedName.lower();
if (!isValidName(type)) {
ec = INVALID_CHARACTER_ERR;
return;
}
if (!constructorBuilder->validateOptions()) {
ec = INVALID_STATE_ERR;
return;
}
QualifiedName tagName = nullQName();
if (!constructorBuilder->findTagName(type, tagName)) {
ec = NAMESPACE_ERR;
return;
}
ASSERT(tagName.namespaceURI() == HTMLNames::xhtmlNamespaceURI || tagName.namespaceURI() == SVGNames::svgNamespaceURI);
if (m_definitions.contains(type)) {
ec = INVALID_STATE_ERR;
return;
}
RefPtr<CustomElementCallback> lifecycleCallbacks = constructorBuilder->createCallback(document());
// Consulting the constructor builder could execute script and
// kill the document.
if (!document()) {
ec = INVALID_STATE_ERR;
return;
}
RefPtr<CustomElementDefinition> definition = CustomElementDefinition::create(type, tagName.localName(), tagName.namespaceURI(), lifecycleCallbacks);
if (!constructorBuilder->createConstructor(document(), definition.get())) {
ec = NOT_SUPPORTED_ERR;
return;
}
m_definitions.add(definition->type(), definition);
// Upgrade elements that were waiting for this definition.
CustomElementUpgradeCandidateMap::ElementSet upgradeCandidates = m_candidates.takeUpgradeCandidatesFor(definition.get());
constructorBuilder->didRegisterDefinition(definition.get(), upgradeCandidates);
for (CustomElementUpgradeCandidateMap::ElementSet::iterator it = upgradeCandidates.begin(); it != upgradeCandidates.end(); ++it) {
(*it)->setNeedsStyleRecalc(); // :unresolved has changed
enqueueReadyCallback(lifecycleCallbacks.get(), *it);
}
}
CustomElementDefinition* CustomElementRegistry::registerElement(Document* document, CustomElementConstructorBuilder* constructorBuilder, const AtomicString& userSuppliedName, CustomElement::NameSet validNames, ExceptionState& exceptionState)
{
AtomicString type = userSuppliedName.lower();
if (!constructorBuilder->isFeatureAllowed()) {
CustomElementException::throwException(CustomElementException::CannotRegisterFromExtension, type, exceptionState);
return 0;
}
if (!CustomElement::isValidName(type, validNames)) {
CustomElementException::throwException(CustomElementException::InvalidName, type, exceptionState);
return 0;
}
if (m_registeredTypeNames.contains(type)) {
CustomElementException::throwException(CustomElementException::TypeAlreadyRegistered, type, exceptionState);
return 0;
}
QualifiedName tagName = QualifiedName::null();
if (!constructorBuilder->validateOptions(type, tagName, exceptionState))
return 0;
ASSERT(tagName.namespaceURI() == HTMLNames::xhtmlNamespaceURI || tagName.namespaceURI() == SVGNames::svgNamespaceURI);
ASSERT(!m_documentWasDetached);
RefPtrWillBeRawPtr<CustomElementLifecycleCallbacks> lifecycleCallbacks = constructorBuilder->createCallbacks();
// Consulting the constructor builder could execute script and
// kill the document.
if (m_documentWasDetached) {
CustomElementException::throwException(CustomElementException::ContextDestroyedCreatingCallbacks, type, exceptionState);
return 0;
}
const CustomElementDescriptor descriptor(type, tagName.namespaceURI(), tagName.localName());
RefPtrWillBeRawPtr<CustomElementDefinition> definition = CustomElementDefinition::create(descriptor, lifecycleCallbacks);
if (!constructorBuilder->createConstructor(document, definition.get(), exceptionState))
return 0;
m_definitions.add(descriptor, definition);
m_registeredTypeNames.add(descriptor.type());
if (!constructorBuilder->didRegisterDefinition(definition.get())) {
CustomElementException::throwException(CustomElementException::ContextDestroyedRegisteringDefinition, type, exceptionState);
return 0;
}
return definition.get();
}
PassRefPtrWillBeRawPtr<Element> CustomElementRegistrationContext::createCustomTagElement(Document& document, const QualifiedName& tagName)
{
ASSERT(CustomElement::isValidName(tagName.localName()));
RefPtrWillBeRawPtr<Element> element;
if (HTMLNames::xhtmlNamespaceURI == tagName.namespaceURI()) {
element = HTMLElement::create(tagName, document);
} else if (SVGNames::svgNamespaceURI == tagName.namespaceURI()) {
element = SVGUnknownElement::create(tagName, document);
} else {
// XML elements are not custom elements, so return early.
return Element::create(tagName, &document);
}
element->setCustomElementState(Element::WaitingForUpgrade);
resolveOrScheduleResolution(element.get(), nullAtom);
return element.release();
}
bool HTMLDocument::isCaseSensitiveAttribute(
const QualifiedName& attributeName) {
static HashSet<StringImpl*>* htmlCaseInsensitiveAttributesSet =
createHtmlCaseInsensitiveAttributesSet();
bool isPossibleHTMLAttr =
!attributeName.hasPrefix() && (attributeName.namespaceURI() == nullAtom);
return !isPossibleHTMLAttr ||
!htmlCaseInsensitiveAttributesSet->contains(
attributeName.localName().impl());
}
CSSPropertyID SVGElement::cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
{
if (!attrName.namespaceURI().isNull())
return CSSPropertyInvalid;
static NeverDestroyed<HashMap<AtomicStringImpl*, CSSPropertyID>> properties;
if (properties.get().isEmpty())
populateAttributeNameToCSSPropertyIDMap(properties.get());
return properties.get().get(attrName.localName().impl());
}
PassRefPtr<Element> CustomElementRegistry::createElement(const QualifiedName& localName, const AtomicString& typeExtension) const
{
const QualifiedName& typeName = QualifiedName(nullAtom, typeExtension, localName.namespaceURI());
if (RefPtr<CustomElementConstructor> found = find(typeName, localName)) {
RefPtr<Element> created = found->createElement();
if (!typeName.localName().isEmpty() && localName != typeName)
return setTypeExtension(created, typeExtension);
return created.release();
}
return 0;
}
static bool findAttributeWithName(const HTMLToken& token, const QualifiedName& name, size_t& indexOfMatchingAttribute)
{
// Notice that we're careful not to ref the StringImpl here because we might be on a background thread.
const String& attrName = name.namespaceURI() == XLinkNames::xlinkNamespaceURI ? "xlink:" + name.localName().string() : name.localName().string();
for (size_t i = 0; i < token.attributes().size(); ++i) {
if (equalIgnoringNullity(token.attributes().at(i).name, attrName)) {
indexOfMatchingAttribute = i;
return true;
}
}
return false;
}
void SelectorDataList::collectElementsByTagName(ContainerNode& rootNode, const QualifiedName& tagName, typename SelectorQueryTrait::OutputType& output) const
{
for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
// querySelector*() doesn't allow namespaces and throws before it gets
// here so we can ignore them.
ASSERT(tagName.namespaceURI() == starAtom);
if (matchesTagName(tagName, element)) {
SelectorQueryTrait::appendElement(output, element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
static CSSPropertyID cssPropertyIdForFontFaceAttributeName(const QualifiedName& attrName)
{
if (!attrName.namespaceURI().isNull())
return CSSPropertyInvalid;
static HashMap<StringImpl*, CSSPropertyID>* propertyNameToIdMap = 0;
if (!propertyNameToIdMap) {
propertyNameToIdMap = new HashMap<StringImpl*, CSSPropertyID>;
// This is a list of all @font-face CSS properties which are exposed as SVG XML attributes
// Those commented out are not yet supported by WebCore's style system
// mapAttributeToCSSProperty(propertyNameToIdMap, accent_heightAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, alphabeticAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, ascentAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, bboxAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, cap_heightAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, descentAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_familyAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_sizeAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_stretchAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_styleAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_variantAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_weightAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, hangingAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, ideographicAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, mathematicalAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, overline_positionAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, overline_thicknessAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, panose_1Attr);
// mapAttributeToCSSProperty(propertyNameToIdMap, slopeAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, stemhAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, stemvAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_positionAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_thicknessAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, underline_positionAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, underline_thicknessAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, unicode_rangeAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, units_per_emAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_alphabeticAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_hangingAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_ideographicAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_mathematicalAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, widthsAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, x_heightAttr);
}
return propertyNameToIdMap->get(attrName.localName().impl());
}
void ScriptCustomElementDefinition::runAttributeChangedCallback(
Element* element,
const QualifiedName& name,
const AtomicString& oldValue,
const AtomicString& newValue) {
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Isolate* isolate = m_scriptState->isolate();
v8::Local<v8::Value> argv[] = {
v8String(isolate, name.localName()), v8StringOrNull(isolate, oldValue),
v8StringOrNull(isolate, newValue),
v8StringOrNull(isolate, name.namespaceURI()),
};
runCallback(m_attributeChangedCallback.newLocal(isolate), element,
WTF_ARRAY_LENGTH(argv), argv);
}
void MarkupAccumulator::appendAttribute(StringBuilder& result, const Element& element, const Attribute& attribute, Namespaces* namespaces)
{
bool documentIsHTML = element.document().isHTMLDocument();
result.append(' ');
QualifiedName prefixedName = attribute.name();
if (documentIsHTML && !attributeIsInSerializedNamespace(attribute))
result.append(attribute.name().localName());
else {
if (!attribute.namespaceURI().isEmpty()) {
AtomicStringImpl* foundNS = namespaces && attribute.prefix().impl() ? namespaces->get(attribute.prefix().impl()) : 0;
bool prefixIsAlreadyMappedToOtherNS = foundNS && foundNS != attribute.namespaceURI().impl();
if (attribute.prefix().isEmpty() || !foundNS || prefixIsAlreadyMappedToOtherNS) {
if (AtomicStringImpl* prefix = namespaces ? namespaces->get(attribute.namespaceURI().impl()) : 0)
prefixedName.setPrefix(AtomicString(prefix));
else {
bool shouldBeDeclaredUsingAppendNamespace = !attribute.prefix().isEmpty() && !foundNS;
if (!shouldBeDeclaredUsingAppendNamespace && attribute.localName() != xmlnsAtom && namespaces)
generateUniquePrefix(prefixedName, *namespaces);
}
}
}
result.append(prefixedName.toString());
}
result.append('=');
if (element.isURLAttribute(attribute))
appendQuotedURLAttributeValue(result, element, attribute);
else {
result.append('"');
appendAttributeValue(result, attribute.value(), documentIsHTML);
result.append('"');
}
if ((inXMLFragmentSerialization() || !documentIsHTML) && namespaces && shouldAddNamespaceAttribute(attribute, *namespaces))
appendNamespace(result, prefixedName.prefix(), prefixedName.namespaceURI(), *namespaces);
}
void MarkupAccumulator::appendAttribute(StringBuilder& result, const Element& element, const Attribute& attribute, Namespaces* namespaces)
{
bool documentIsHTML = serializeAsHTMLDocument(element);
result.append(' ');
QualifiedName prefixedName = attribute.name();
if (documentIsHTML && !attributeIsInSerializedNamespace(attribute)) {
result.append(attribute.name().localName());
} else {
if (attribute.namespaceURI() == XLinkNames::xlinkNamespaceURI) {
if (!attribute.prefix())
prefixedName.setPrefix(xlinkAtom);
} else if (attribute.namespaceURI() == XMLNames::xmlNamespaceURI) {
if (!attribute.prefix())
prefixedName.setPrefix(xmlAtom);
} else if (attribute.namespaceURI() == XMLNSNames::xmlnsNamespaceURI) {
if (attribute.name() != XMLNSNames::xmlnsAttr && !attribute.prefix())
prefixedName.setPrefix(xmlnsAtom);
}
result.append(prefixedName.toString());
}
result.append('=');
if (element.isURLAttribute(attribute)) {
appendQuotedURLAttributeValue(result, element, attribute);
} else {
result.append('"');
appendAttributeValue(result, attribute.value(), documentIsHTML);
result.append('"');
}
if (!documentIsHTML && namespaces && shouldAddNamespaceAttribute(attribute, *namespaces))
appendNamespace(result, prefixedName.prefix(), prefixedName.namespaceURI(), *namespaces);
}
bool Element::hasAttribute(const QualifiedName& name) const
{
return hasAttributeNS(name.namespaceURI(), name.localName());
}
CSSPropertyID SVGElement::cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
{
if (!attrName.namespaceURI().isNull())
return CSSPropertyInvalid;
static HashMap<StringImpl*, CSSPropertyID>* propertyNameToIdMap = 0;
if (!propertyNameToIdMap) {
propertyNameToIdMap = new HashMap<StringImpl*, CSSPropertyID>;
// This is a list of all base CSS and SVG CSS properties which are exposed as SVG XML attributes
const QualifiedName* const attrNames[] = {
&alignment_baselineAttr,
&baseline_shiftAttr,
&buffered_renderingAttr,
&clipAttr,
&clip_pathAttr,
&clip_ruleAttr,
&SVGNames::colorAttr,
&color_interpolationAttr,
&color_interpolation_filtersAttr,
&color_renderingAttr,
&cursorAttr,
&SVGNames::directionAttr,
&displayAttr,
&dominant_baselineAttr,
&fillAttr,
&fill_opacityAttr,
&fill_ruleAttr,
&filterAttr,
&flood_colorAttr,
&flood_opacityAttr,
&font_familyAttr,
&font_sizeAttr,
&font_stretchAttr,
&font_styleAttr,
&font_variantAttr,
&font_weightAttr,
&image_renderingAttr,
&letter_spacingAttr,
&lighting_colorAttr,
&marker_endAttr,
&marker_midAttr,
&marker_startAttr,
&maskAttr,
&mask_typeAttr,
&opacityAttr,
&overflowAttr,
&paint_orderAttr,
&pointer_eventsAttr,
&shape_renderingAttr,
&stop_colorAttr,
&stop_opacityAttr,
&strokeAttr,
&stroke_dasharrayAttr,
&stroke_dashoffsetAttr,
&stroke_linecapAttr,
&stroke_linejoinAttr,
&stroke_miterlimitAttr,
&stroke_opacityAttr,
&stroke_widthAttr,
&text_anchorAttr,
&text_decorationAttr,
&text_renderingAttr,
&transform_originAttr,
&unicode_bidiAttr,
&vector_effectAttr,
&visibilityAttr,
&word_spacingAttr,
&writing_modeAttr,
};
for (size_t i = 0; i < WTF_ARRAY_LENGTH(attrNames); i++) {
CSSPropertyID propertyId = cssPropertyID(attrNames[i]->localName());
ASSERT(propertyId > 0);
propertyNameToIdMap->set(attrNames[i]->localName().impl(), propertyId);
}
}
return propertyNameToIdMap->get(attrName.localName().impl());
}
static PassRefPtr<HTMLElement> imgToimageConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement* formElement, bool)
{
return HTMLImageElement::create(QualifiedName(tagName.prefix(), imgTag.localName(), tagName.namespaceURI()), document, formElement);
}
AtomicString HTMLElement::eventNameForAttributeName(const QualifiedName& attrName) const
{
if (!attrName.namespaceURI().isNull())
return AtomicString();
typedef HashMap<AtomicString, AtomicString> StringToStringMap;
DEFINE_STATIC_LOCAL(StringToStringMap, attributeNameToEventNameMap, ());
if (!attributeNameToEventNameMap.size()) {
attributeNameToEventNameMap.set(onclickAttr.localName(), eventNames().clickEvent);
attributeNameToEventNameMap.set(oncontextmenuAttr.localName(), eventNames().contextmenuEvent);
attributeNameToEventNameMap.set(ondblclickAttr.localName(), eventNames().dblclickEvent);
attributeNameToEventNameMap.set(onmousedownAttr.localName(), eventNames().mousedownEvent);
attributeNameToEventNameMap.set(onmouseenterAttr.localName(), eventNames().mouseenterEvent);
attributeNameToEventNameMap.set(onmouseleaveAttr.localName(), eventNames().mouseleaveEvent);
attributeNameToEventNameMap.set(onmousemoveAttr.localName(), eventNames().mousemoveEvent);
attributeNameToEventNameMap.set(onmouseoutAttr.localName(), eventNames().mouseoutEvent);
attributeNameToEventNameMap.set(onmouseoverAttr.localName(), eventNames().mouseoverEvent);
attributeNameToEventNameMap.set(onmouseupAttr.localName(), eventNames().mouseupEvent);
attributeNameToEventNameMap.set(onmousewheelAttr.localName(), eventNames().mousewheelEvent);
attributeNameToEventNameMap.set(onfocusAttr.localName(), eventNames().focusEvent);
attributeNameToEventNameMap.set(onfocusinAttr.localName(), eventNames().focusinEvent);
attributeNameToEventNameMap.set(onfocusoutAttr.localName(), eventNames().focusoutEvent);
attributeNameToEventNameMap.set(onblurAttr.localName(), eventNames().blurEvent);
attributeNameToEventNameMap.set(onkeydownAttr.localName(), eventNames().keydownEvent);
attributeNameToEventNameMap.set(onkeypressAttr.localName(), eventNames().keypressEvent);
attributeNameToEventNameMap.set(onkeyupAttr.localName(), eventNames().keyupEvent);
attributeNameToEventNameMap.set(onscrollAttr.localName(), eventNames().scrollEvent);
attributeNameToEventNameMap.set(onbeforecutAttr.localName(), eventNames().beforecutEvent);
attributeNameToEventNameMap.set(oncutAttr.localName(), eventNames().cutEvent);
attributeNameToEventNameMap.set(onbeforecopyAttr.localName(), eventNames().beforecopyEvent);
attributeNameToEventNameMap.set(oncopyAttr.localName(), eventNames().copyEvent);
attributeNameToEventNameMap.set(onbeforepasteAttr.localName(), eventNames().beforepasteEvent);
attributeNameToEventNameMap.set(onpasteAttr.localName(), eventNames().pasteEvent);
attributeNameToEventNameMap.set(ondragenterAttr.localName(), eventNames().dragenterEvent);
attributeNameToEventNameMap.set(ondragoverAttr.localName(), eventNames().dragoverEvent);
attributeNameToEventNameMap.set(ondragleaveAttr.localName(), eventNames().dragleaveEvent);
attributeNameToEventNameMap.set(ondropAttr.localName(), eventNames().dropEvent);
attributeNameToEventNameMap.set(ondragstartAttr.localName(), eventNames().dragstartEvent);
attributeNameToEventNameMap.set(ondragAttr.localName(), eventNames().dragEvent);
attributeNameToEventNameMap.set(ondragendAttr.localName(), eventNames().dragendEvent);
attributeNameToEventNameMap.set(onselectstartAttr.localName(), eventNames().selectstartEvent);
attributeNameToEventNameMap.set(onsubmitAttr.localName(), eventNames().submitEvent);
attributeNameToEventNameMap.set(onerrorAttr.localName(), eventNames().errorEvent);
attributeNameToEventNameMap.set(onwebkitanimationstartAttr.localName(), eventNames().webkitAnimationStartEvent);
attributeNameToEventNameMap.set(onwebkitanimationiterationAttr.localName(), eventNames().webkitAnimationIterationEvent);
attributeNameToEventNameMap.set(onwebkitanimationendAttr.localName(), eventNames().webkitAnimationEndEvent);
attributeNameToEventNameMap.set(onwebkittransitionendAttr.localName(), eventNames().webkitTransitionEndEvent);
attributeNameToEventNameMap.set(ontransitionendAttr.localName(), eventNames().webkitTransitionEndEvent);
attributeNameToEventNameMap.set(oninputAttr.localName(), eventNames().inputEvent);
attributeNameToEventNameMap.set(oninvalidAttr.localName(), eventNames().invalidEvent);
attributeNameToEventNameMap.set(ontouchstartAttr.localName(), eventNames().touchstartEvent);
attributeNameToEventNameMap.set(ontouchmoveAttr.localName(), eventNames().touchmoveEvent);
attributeNameToEventNameMap.set(ontouchendAttr.localName(), eventNames().touchendEvent);
attributeNameToEventNameMap.set(ontouchcancelAttr.localName(), eventNames().touchcancelEvent);
#if ENABLE(FULLSCREEN_API)
attributeNameToEventNameMap.set(onwebkitfullscreenchangeAttr.localName(), eventNames().webkitfullscreenchangeEvent);
attributeNameToEventNameMap.set(onwebkitfullscreenerrorAttr.localName(), eventNames().webkitfullscreenerrorEvent);
#endif
attributeNameToEventNameMap.set(onabortAttr.localName(), eventNames().abortEvent);
attributeNameToEventNameMap.set(oncanplayAttr.localName(), eventNames().canplayEvent);
attributeNameToEventNameMap.set(oncanplaythroughAttr.localName(), eventNames().canplaythroughEvent);
attributeNameToEventNameMap.set(onchangeAttr.localName(), eventNames().changeEvent);
attributeNameToEventNameMap.set(ondurationchangeAttr.localName(), eventNames().durationchangeEvent);
attributeNameToEventNameMap.set(onemptiedAttr.localName(), eventNames().emptiedEvent);
attributeNameToEventNameMap.set(onendedAttr.localName(), eventNames().endedEvent);
attributeNameToEventNameMap.set(onloadeddataAttr.localName(), eventNames().loadeddataEvent);
attributeNameToEventNameMap.set(onloadedmetadataAttr.localName(), eventNames().loadedmetadataEvent);
attributeNameToEventNameMap.set(onloadstartAttr.localName(), eventNames().loadstartEvent);
attributeNameToEventNameMap.set(onpauseAttr.localName(), eventNames().pauseEvent);
attributeNameToEventNameMap.set(onplayAttr.localName(), eventNames().playEvent);
attributeNameToEventNameMap.set(onplayingAttr.localName(), eventNames().playingEvent);
attributeNameToEventNameMap.set(onprogressAttr.localName(), eventNames().progressEvent);
attributeNameToEventNameMap.set(onratechangeAttr.localName(), eventNames().ratechangeEvent);
attributeNameToEventNameMap.set(onresetAttr.localName(), eventNames().resetEvent);
attributeNameToEventNameMap.set(onseekedAttr.localName(), eventNames().seekedEvent);
attributeNameToEventNameMap.set(onseekingAttr.localName(), eventNames().seekingEvent);
attributeNameToEventNameMap.set(onselectAttr.localName(), eventNames().selectEvent);
attributeNameToEventNameMap.set(onstalledAttr.localName(), eventNames().stalledEvent);
attributeNameToEventNameMap.set(onsuspendAttr.localName(), eventNames().suspendEvent);
attributeNameToEventNameMap.set(ontimeupdateAttr.localName(), eventNames().timeupdateEvent);
attributeNameToEventNameMap.set(onvolumechangeAttr.localName(), eventNames().volumechangeEvent);
attributeNameToEventNameMap.set(onwaitingAttr.localName(), eventNames().waitingEvent);
attributeNameToEventNameMap.set(onloadAttr.localName(), eventNames().loadEvent);
}
return attributeNameToEventNameMap.get(attrName.localName());
}
int SVGStyledElement::cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
{
if (!attrName.namespaceURI().isNull())
return 0;
static HashMap<AtomicStringImpl*, int>* propertyNameToIdMap = 0;
if (!propertyNameToIdMap) {
propertyNameToIdMap = new HashMap<AtomicStringImpl*, int>;
// This is a list of all base CSS and SVG CSS properties which are exposed as SVG XML attributes
mapAttributeToCSSProperty(propertyNameToIdMap, alignment_baselineAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, baseline_shiftAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, clipAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, clip_pathAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, clip_ruleAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, SVGNames::colorAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, color_interpolationAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, color_interpolation_filtersAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, color_profileAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, color_renderingAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, cursorAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, SVGNames::directionAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, displayAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, dominant_baselineAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, enable_backgroundAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, fillAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, fill_opacityAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, fill_ruleAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, filterAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, flood_colorAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, flood_opacityAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_familyAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_sizeAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_stretchAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_styleAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_variantAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_weightAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, glyph_orientation_horizontalAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, glyph_orientation_verticalAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, image_renderingAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, kerningAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, letter_spacingAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, lighting_colorAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, marker_endAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, marker_midAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, marker_startAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, maskAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, opacityAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, overflowAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, pointer_eventsAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, shape_renderingAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stop_colorAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stop_opacityAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, strokeAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stroke_dasharrayAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stroke_dashoffsetAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stroke_linecapAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stroke_linejoinAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stroke_miterlimitAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stroke_opacityAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, stroke_widthAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, text_anchorAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, text_decorationAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, text_renderingAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, unicode_bidiAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, visibilityAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, word_spacingAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, writing_modeAttr);
}
return propertyNameToIdMap->get(attrName.localName().impl());
}
static bool anyAttributeMatches(Element* element, const CSSSelector* selector, const QualifiedName& selectorAttr, bool caseSensitive)
{
ASSERT(element->hasAttributesWithoutUpdate());
for (size_t i = 0, count = element->attributeCount(); i < count; ++i) {
const Attribute& attribute = element->attributeAt(i);
if (!attribute.matches(selectorAttr.prefix(), element->isHTMLElement() ? selector->attributeCanonicalLocalName() : selectorAttr.localName(), selectorAttr.namespaceURI()))
continue;
if (attributeValueMatches(attribute, static_cast<CSSSelector::Match>(selector->m_match), selector->value(), caseSensitive))
return true;
}
return false;
}