Simplify Custom Element constructors to be functions, not wrappers

Source/core/dom/CustomElementRegistry.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 81 matching lines @@
         reservedNames.append(SVGNames::font_face_nameTag.localName());
         reservedNames.append(SVGNames::missing_glyphTag.localName());
     }
 
     if (notFound != reservedNames.find(name))
         return false;
 
     return Document::isValidName(name.string());
 }
 
-PassRefPtr<CustomElementConstructor> CustomElementRegistry::registerElement(ScriptState* state, const AtomicString& userSuppliedName, const Dictionary& options, ExceptionCode& ec)
+ScriptValue CustomElementRegistry::registerElement(ScriptState* state, const AtomicString& userSuppliedName, const Dictionary& options, ExceptionCode& ec)
 {
     RefPtr<CustomElementRegistry> protect(this);
 
     if (!CustomElementHelpers::isFeatureAllowed(state))
-        return 0;
+        return ScriptValue();
 
     AtomicString name = userSuppliedName.lower();
     if (!isValidName(name)) {
         ec = INVALID_CHARACTER_ERR;
-        return 0;
+        return ScriptValue();
     }
 
     ScriptValue prototypeValue;
     if (!options.get("prototype", prototypeValue)) {
         // FIXME: Implement the default value handling.
         // Currently default value of the "prototype" parameter, which
         // is HTMLSpanElement.prototype, has an ambiguity about its
         // behavior. The spec should be fixed before WebKit implements
         // it. https://www.w3.org/Bugs/Public/show_bug.cgi?id=20801
         ec = INVALID_STATE_ERR;
-        return 0;
+        return ScriptValue();
     }
 
     AtomicString namespaceURI;
     if (!CustomElementHelpers::isValidPrototypeParameter(prototypeValue, state, namespaceURI)) {
         ec = INVALID_STATE_ERR;
-        return 0;
+        return ScriptValue();
     }
 
     if (namespaceURI.isNull()) {
         ec = NAMESPACE_ERR;
-        return 0;
+        return ScriptValue();
     }
 
     AtomicString type = name;
     if (m_definitions.contains(type)) {
         ec = INVALID_STATE_ERR;
-        return 0;
+        return ScriptValue();
     }
 
     const QualifiedName* prototypeTagName = CustomElementHelpers::findLocalName(prototypeValue);
     if (prototypeTagName)
         name = prototypeTagName->localName();
 
     // A script execution could happen in isValidPrototypeParameter(), which kills the document.
     if (!document()) {
         ec = INVALID_STATE_ERR;
-        return 0;
+        return ScriptValue();
     }
 
     ASSERT(name == type || QualifiedName(nullAtom, name, namespaceURI) == *CustomElementHelpers::findLocalName(prototypeValue));
     ASSERT(namespaceURI == HTMLNames::xhtmlNamespaceURI || namespaceURI == SVGNames::svgNamespaceURI);
 
     RefPtr<CustomElementDefinition> definition = CustomElementDefinition::create(type, name, namespaceURI);
-    RefPtr<CustomElementConstructor> constructor = CustomElementConstructor::create(document(), definition->tagQName(), definition->isTypeExtension() ? definition->type() : nullAtom);
-    if (!CustomElementHelpers::initializeConstructorWrapper(constructor.get(), prototypeValue, state)) {
+    ScriptValue constructor = CustomElementHelpers::createConstructor(state, prototypeValue, document(), definition->namespaceURI(), definition->name(), definition->isTypeExtension() ? definition->type() : nullAtom);
+    if (constructor.hasNoValue()) {
         ec = INVALID_STATE_ERR;
-        return 0;
+        return ScriptValue();
     }
+    ASSERT(constructor.isFunction());
 
     m_definitions.add(definition->type(), definition);
 
     // Upgrade elements that were waiting for this definition.
     CustomElementUpgradeCandidateMap::ElementSet upgradeCandidates = m_candidates.takeUpgradeCandidatesFor(definition.get());
     CustomElementHelpers::didRegisterDefinition(definition.get(), document(), upgradeCandidates, prototypeValue);
     for (CustomElementUpgradeCandidateMap::ElementSet::iterator it = upgradeCandidates.begin(); it != upgradeCandidates.end(); ++it) {
         (*it)->setNeedsStyleRecalc(); // :unresolved has changed
         activate(CustomElementInvocation(*it));
     }
 
-    return constructor.release();
+    return constructor;
 }
 
 bool CustomElementRegistry::isUnresolved(Element* element) const
 {
     return m_candidates.contains(element);
 }
 
 PassRefPtr<CustomElementDefinition> CustomElementRegistry::findFor(Element* element) const
 {
     ASSERT(element->document()->registry() == this);
@@ skipping 129 matching lines @@
     while (!activeCustomElementRegistries().isEmpty()) {
         Vector<RefPtr<CustomElementRegistry> > registries;
         copyToVector(activeCustomElementRegistries(), registries);
         activeCustomElementRegistries().clear();
         for (size_t i = 0; i < registries.size(); ++i)
             registries[i]->deliverLifecycleCallbacks();
     }
 }
 
 }