Changeset 147113 in webkit

Timestamp:

Mar 28, 2013 7:34:21 AM (11 years ago)

Author:

morrita@google.com

Message:

Custom Elements: should support non-HTML namespaces.
​https://bugs.webkit.org/show_bug.cgi?id=111693

Reviewed by Dimitri Glazkov.

Source/WebCore:

Some existing code assumes that the element extends HTMLElements.
This change allow it to extend from Element. Note that the
namespace URI of a custom element is determined by given element
prototype: An element will have XHTML namespace if its prototype
chain includes HTMLElements, SVGElement leads SVG namespace and
null otherwise, respectively.

Test: fast/dom/custom/document-register-namespace.html

• bindings/v8/CustomElementHelpers.cpp:

(WebCore::hasValidPrototypeChainFor): Factored out from isValidPrototypeParameter()
(WebCore::CustomElementHelpers::isValidPrototypeParameter): Extend to support non HTMLElement prototype
(WebCore::CustomElementHelpers::findLocalName): Support non-HTML element names.

• bindings/v8/CustomElementHelpers.h:

(CustomElementHelpers):

• dom/CustomElementConstructor.cpp:

(WebCore::CustomElementConstructor::createElementInternal):

• dom/CustomElementRegistry.cpp:

(WebCore::CustomElementRegistry::registerElement): No longer hard-codes namespace and picks one based on the prototype value.

• dom/CustomElementRegistry.h:

(CustomElementRegistry):

LayoutTests:

• fast/dom/custom/document-register-namespace-expected.txt: Added.
• fast/dom/custom/document-register-namespace.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/dom/custom/document-register-namespace-expected.txt (added)
• LayoutTests/fast/dom/custom/document-register-namespace.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/bindings/v8/CustomElementHelpers.cpp (modified) (4 diffs)
• Source/WebCore/bindings/v8/CustomElementHelpers.h (modified) (2 diffs)
• Source/WebCore/dom/CustomElementConstructor.cpp (modified) (2 diffs)
• Source/WebCore/dom/CustomElementRegistry.cpp (modified) (5 diffs)
• Source/WebCore/dom/CustomElementRegistry.h (modified) (3 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2013-03-28  Hajime Morrita  <morrita@google.com>
+
+        Custom Elements: should support non-HTML namespaces.
+        https://bugs.webkit.org/show_bug.cgi?id=111693
+
+        Reviewed by Dimitri Glazkov.
+
+        * fast/dom/custom/document-register-namespace-expected.txt: Added.
+        * fast/dom/custom/document-register-namespace.html: Added.
+
 2013-03-28  Christophe Dumez  <ch.dumez@sisa.samsung.com>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-03-28  Hajime Morrita  <morrita@google.com>
+
+        Custom Elements: should support non-HTML namespaces.
+        https://bugs.webkit.org/show_bug.cgi?id=111693
+
+        Reviewed by Dimitri Glazkov.
+
+        Some existing code assumes that the element extends HTMLElements.
+        This change allow it to extend from Element. Note that the
+        namespace URI of a custom element is determined by given element
+        prototype: An element will have XHTML namespace if its prototype
+        chain includes HTMLElements, SVGElement leads SVG namespace and
+        null otherwise, respectively.
+
+        Test: fast/dom/custom/document-register-namespace.html
+
+        * bindings/v8/CustomElementHelpers.cpp:
+        (WebCore::hasValidPrototypeChainFor): Factored out from isValidPrototypeParameter()
+        (WebCore::CustomElementHelpers::isValidPrototypeParameter): Extend to support non HTMLElement prototype
+        (WebCore::CustomElementHelpers::findLocalName): Support non-HTML element names.
+        * bindings/v8/CustomElementHelpers.h:
+        (CustomElementHelpers):
+        * dom/CustomElementConstructor.cpp:
+        (WebCore::CustomElementConstructor::createElementInternal):
+        * dom/CustomElementRegistry.cpp:
+        (WebCore::CustomElementRegistry::registerElement): No longer hard-codes namespace and picks one based on the prototype value.
+        * dom/CustomElementRegistry.h:
+        (CustomElementRegistry):
+
 2013-03-28  Hans Muller  <hmuller@adobe.com>
 

trunk/Source/WebCore/bindings/v8/CustomElementHelpers.cpp

@@ -34 +34 @@
 #include "CustomElementRegistry.h"
 #include "DOMWrapperWorld.h"
+#include "SVGNames.h"
 #include "ScriptController.h"
 #include "V8CustomElementConstructor.h"
 #include "V8HTMLElementWrapperFactory.h"
-#include "V8HTMLParagraphElement.h"
-#include "V8HTMLSpanElement.h"
+#include "V8SVGElementWrapperFactory.h"
+
 
 namespace WebCore {
@@ -99 +100 @@
 }
 
-static bool hasValidPrototypeChain(v8::Handle<v8::Object> requiredAncestor, v8::Handle<v8::Value> chain)
-{
+static bool hasValidPrototypeChainFor(v8::Handle<v8::Object> prototypeObject, WrapperTypeInfo* typeInfo, v8::Handle<v8::Context> context)
+{
+    // document.register() sets the constructor property, so the prototype shouldn't have one.
+    if (prototypeObject->HasOwnProperty(v8String("constructor", context->GetIsolate())))
+        return false;
+
+    v8::Handle<v8::Object> elementConstructor = v8::Handle<v8::Object>::Cast(V8PerContextData::from(context)->constructorForType(typeInfo));
+    if (elementConstructor.IsEmpty())
+        return false;
+    v8::Handle<v8::Object> elementPrototype = v8::Handle<v8::Object>::Cast(elementConstructor->Get(v8String("prototype", context->GetIsolate())));
+    if (elementPrototype.IsEmpty())
+        return false;
+
+    v8::Handle<v8::Value> chain = prototypeObject;
     while (!chain.IsEmpty() && chain->IsObject()) {
-        if (chain == requiredAncestor)
+        if (chain == elementPrototype)
             return true;
         chain = v8::Handle<v8::Object>::Cast(chain)->GetPrototype();
@@ -110 +123 @@
 }
 
-bool CustomElementHelpers::isValidPrototypeParameter(const ScriptValue& prototype, ScriptState* state)
+bool CustomElementHelpers::isValidPrototypeParameter(const ScriptValue& prototype, ScriptState* state, AtomicString& namespaceURI)
 {
     if (prototype.v8Value().IsEmpty() || !prototype.v8Value()->IsObject())
         return false;
 
-    // document.register() sets the constructor property, so the prototype shouldn't have one.
     v8::Handle<v8::Object> prototypeObject = v8::Handle<v8::Object>::Cast(prototype.v8Value());
-    if (prototypeObject->HasOwnProperty(v8String("constructor", state->context()->GetIsolate())))
-        return false;
-    V8PerContextData* perContextData = V8PerContextData::from(state->context());
-    // FIXME: non-HTML subclasses should be also supported: https://bugs.webkit.org/show_bug.cgi?id=111693
-    v8::Handle<v8::Object> htmlConstructor = v8::Handle<v8::Object>::Cast(perContextData->constructorForType(&V8HTMLElement::info));
-    if (htmlConstructor.IsEmpty())
-        return false;
-    v8::Handle<v8::Object> htmlPrototype = v8::Handle<v8::Object>::Cast(htmlConstructor->Get(v8String("prototype", state->context()->GetIsolate())));
-    if (htmlPrototype.IsEmpty())
-        return false;
-    if (!hasValidPrototypeChain(htmlPrototype, prototypeObject))
-        return false;
-    return true;
+    if (hasValidPrototypeChainFor(prototypeObject, &V8HTMLElement::info, state->context())) {
+        namespaceURI = HTMLNames::xhtmlNamespaceURI;
+        return true;
+    }
+
+#if ENABLE(SVG)
+    if (hasValidPrototypeChainFor(prototypeObject, &V8SVGElement::info, state->context())) {
+        namespaceURI = SVGNames::svgNamespaceURI;
+        return true;
+    }
+#endif
+
+    if (hasValidPrototypeChainFor(prototypeObject, &V8Element::info, state->context())) {
+        namespaceURI = nullAtom;
+        return true;
+    }
+
+    return false;
 }
 
@@ -170 +187 @@
     if (!type)
         return 0;
-    return findHTMLTagNameOfV8Type(type);
+    if (const QualifiedName* htmlName = findHTMLTagNameOfV8Type(type))
+        return htmlName;
+#if ENABLE(SVG)
+    if (const QualifiedName* svgName = findSVGTagNameOfV8Type(type))
+        return svgName;
+#endif
+    return 0;
 }
 

trunk/Source/WebCore/bindings/v8/CustomElementHelpers.h

@@ -57 +57 @@
 public:
     static bool initializeConstructorWrapper(CustomElementConstructor*, const ScriptValue& prototype, ScriptState*);
+    static bool isValidPrototypeParameter(const ScriptValue&, ScriptState*, AtomicString& namespaceURI);
     static bool isValidPrototypeParameter(const ScriptValue&, ScriptState*);
     static bool isFeatureAllowed(ScriptState*);
@@ -94 +95 @@
 }
 
+inline bool CustomElementHelpers::isValidPrototypeParameter(const ScriptValue& value, ScriptState* state)
+{
+    AtomicString namespaceURI;
+    return isValidPrototypeParameter(value, state, namespaceURI);
+}
+
 #endif // ENABLE(CUSTOM_ELEMENTS)
 

trunk/Source/WebCore/dom/CustomElementConstructor.cpp

@@ -39 +39 @@
 #include "HTMLElement.h"
 #include "HTMLNames.h"
+#include "SVGElement.h"
+#include "SVGNames.h"
 #include <wtf/Assertions.h>
 
@@ -78 +80 @@
     if (m_localName != m_typeName)
         return setTypeExtension(document()->createElement(m_localName, document()), m_typeName.localName());
-    return HTMLElement::create(m_typeName, document());
+    if (HTMLNames::xhtmlNamespaceURI == m_typeName.namespaceURI())
+        return HTMLElement::create(m_typeName, document());
+#if ENABLE(SVG)
+    if (SVGNames::svgNamespaceURI == m_typeName.namespaceURI())
+        return SVGElement::create(m_typeName, document());
+#endif
+    return Element::create(m_typeName, document());
 }
 

trunk/Source/WebCore/dom/CustomElementRegistry.cpp

@@ -116 +116 @@
         return 0;
 
-    QualifiedName newName(nullAtom, name.lower(), HTMLNames::xhtmlNamespaceURI);
-    if (!isValidName(newName.localName())) {
+    AtomicString lowerName = name.lower();
+    if (!isValidName(lowerName)) {
         ec = INVALID_CHARACTER_ERR;
         return 0;
@@ -133 +133 @@
     }
 
-    if (!CustomElementHelpers::isValidPrototypeParameter(prototypeValue, state)) {
-        ec = INVALID_STATE_ERR;
-        return 0;
-    }
-
-    if (m_names.contains(newName)) {
+    AtomicString namespaceURI;
+    if (!CustomElementHelpers::isValidPrototypeParameter(prototypeValue, state, namespaceURI)) {
+        ec = INVALID_STATE_ERR;
+        return 0;
+    }
+
+    if (m_names.contains(lowerName)) {
         ec = INVALID_STATE_ERR;
         return 0;
@@ -144 +145 @@
 
     const QualifiedName* localNameFound = CustomElementHelpers::findLocalName(prototypeValue);
-    QualifiedName localNameToUse = localNameFound ? *localNameFound : newName;
-    if (find(newName, localNameToUse)) {
+    QualifiedName typeName(nullAtom, lowerName, namespaceURI);
+    QualifiedName localNameToUse = localNameFound ? *localNameFound : typeName;
+    if (find(typeName, localNameToUse)) {
         ec = INVALID_STATE_ERR;
         return 0;
@@ -156 +158 @@
     }
 
-    RefPtr<CustomElementConstructor> constructor = CustomElementConstructor::create(state, document(), newName, localNameToUse, prototypeValue);
+    RefPtr<CustomElementConstructor> constructor = CustomElementConstructor::create(state, document(), typeName, localNameToUse, prototypeValue);
     if (!constructor) {
         ec = INVALID_STATE_ERR;
@@ -163 +165 @@
         
     m_constructors.add(std::make_pair(constructor->typeName(), constructor->localName()), constructor);
-    m_names.add(constructor->typeName());
+    m_names.add(lowerName);
 
     return constructor;

trunk/Source/WebCore/dom/CustomElementRegistry.h

@@ -39 +39 @@
 #include "ScriptValue.h"
 #include "Supplementable.h"
-#include <wtf/Forward.h>
 #include <wtf/HashSet.h>
 #include <wtf/ListHashSet.h>
@@ -46 +45 @@
 #include <wtf/RefPtr.h>
 #include <wtf/Vector.h>
+#include <wtf/text/AtomicStringHash.h>
 
 namespace WebCore {
@@ -94 +94 @@
 private:
     typedef HashMap<std::pair<QualifiedName, QualifiedName>, RefPtr<CustomElementConstructor> > ConstructorMap;
-    typedef HashSet<QualifiedName> NameSet;
+    typedef HashSet<AtomicString> NameSet;
     typedef ListHashSet<CustomElementRegistry*> InstanceSet;