Custom Elements: Lookup custom element definition algorithm

third_party/WebKit/Source/core/dom/custom/CustomElementRegistry.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/custom/CustomElementRegistry.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptCustomElementDefinitionBuilder.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 72 matching lines @@
       m_upgradeCandidates(new UpgradeCandidateMap()) {}
 
 DEFINE_TRACE(CustomElementRegistry) {
   visitor->trace(m_definitions);
   visitor->trace(m_owner);
   visitor->trace(m_v0);
   visitor->trace(m_upgradeCandidates);
   visitor->trace(m_whenDefinedPromiseMap);
 }
 
-void CustomElementRegistry::define(ScriptState* scriptState,
-                                   const AtomicString& name,
-                                   const ScriptValue& constructor,
-                                   const ElementDefinitionOptions& options,
-                                   ExceptionState& exceptionState) {
+CustomElementDefinition* CustomElementRegistry::define(
+    ScriptState* scriptState,
+    const AtomicString& name,
+    const ScriptValue& constructor,
+    const ElementDefinitionOptions& options,
+    ExceptionState& exceptionState) {
   ScriptCustomElementDefinitionBuilder builder(scriptState, this, constructor,
                                                exceptionState);
-  define(name, builder, options, exceptionState);
+  return define(name, builder, options, exceptionState);
 }
 
 // http://w3c.github.io/webcomponents/spec/custom/#dfn-element-definition
-void CustomElementRegistry::define(const AtomicString& name,
-                                   CustomElementDefinitionBuilder& builder,
-                                   const ElementDefinitionOptions& options,
-                                   ExceptionState& exceptionState) {
+CustomElementDefinition* CustomElementRegistry::define(
+    const AtomicString& name,
+    CustomElementDefinitionBuilder& builder,
+    const ElementDefinitionOptions& options,
+    ExceptionState& exceptionState) {
   TRACE_EVENT1("blink", "CustomElementRegistry::define", "name", name.utf8());
   if (!builder.checkConstructorIntrinsics())
-    return;
+    return nullptr;
 
   if (throwIfInvalidName(name, exceptionState))
-    return;
+    return nullptr;
 
   if (nameIsDefined(name) || v0NameIsDefined(name)) {
     exceptionState.throwDOMException(
         NotSupportedError,
         "this name has already been used with this registry");
-    return;
+    return nullptr;
   }
 
   if (!builder.checkConstructorNotRegistered())
-    return;
+    return nullptr;
 
   AtomicString localName = name;
 
   // Step 7. customized built-in elements definition
   // element interface extends option checks
   if (RuntimeEnabledFeatures::customElementsBuiltinEnabled() &&
       options.hasExtends()) {
     // 7.1. If element interface is valid custom element name, throw exception
     const AtomicString& extends = AtomicString(options.extends());
     if (throwIfValidName(AtomicString(options.extends()), exceptionState))
-      return;
+      return nullptr;
     // 7.2. If element interface is undefined element, throw exception
     if (htmlElementTypeForTag(extends) ==
         HTMLElementType::kHTMLUnknownElement) {
       exceptionState.throwDOMException(
           NotSupportedError, "\"" + extends + "\" is an HTMLUnknownElement");
-      return;
+      return nullptr;
     }
     // 7.3. Set localName to extends
     localName = extends;
   }
 
   // TODO(dominicc): Add a test where the prototype getter destroys
   // the context.
 
   // 8. If this CustomElementRegistry's element definition is
   // running flag is set, then throw a "NotSupportedError"
   // DOMException and abort these steps.
   if (m_elementDefinitionIsRunning) {
     exceptionState.throwDOMException(
         NotSupportedError, "an element definition is already being processed");
-    return;
+    return nullptr;
   }
 
   {
     // 9. Set this CustomElementRegistry's element definition is
     // running flag.
     ElementDefinitionIsRunning defining(m_elementDefinitionIsRunning);
 
     // 10.1-2
     if (!builder.checkPrototype())
-      return;
+      return nullptr;
 
     // 10.3-6
     if (!builder.rememberOriginalProperties())
-      return;
+      return nullptr;
 
     // "Then, perform the following substep, regardless of whether
     // the above steps threw an exception or not: Unset this
     // CustomElementRegistry's element definition is running
     // flag."
     // (ElementDefinitionIsRunning destructor does this.)
   }
 
   CustomElementDescriptor descriptor(name, localName);
   CustomElementDefinition* definition = builder.build(descriptor);
   CHECK(!exceptionState.hadException());
   CHECK(definition->descriptor() == descriptor);
   DefinitionMap::AddResult result =
       m_definitions.add(descriptor.name(), definition);
   CHECK(result.isNewEntry);
 
   HeapVector<Member<Element>> candidates;
   collectCandidates(descriptor, &candidates);
   for (Element* candidate : candidates)
     definition->enqueueUpgradeReaction(candidate);
 
   // 16: when-defined promise processing
   const auto& entry = m_whenDefinedPromiseMap.find(name);
-  if (entry == m_whenDefinedPromiseMap.end())
-    return;
-  entry->value->resolve();
-  m_whenDefinedPromiseMap.remove(entry);
+  if (entry != m_whenDefinedPromiseMap.end()) {
+    entry->value->resolve();
+    m_whenDefinedPromiseMap.remove(entry);
+  }
+  return definition;
 }
 
 // https://html.spec.whatwg.org/multipage/scripting.html#dom-customelementsregistry-get
 ScriptValue CustomElementRegistry::get(const AtomicString& name) {
   CustomElementDefinition* definition = definitionForName(name);
   if (!definition) {
     // Binding layer converts |ScriptValue()| to script specific value,
     // e.g. |undefined| for v8.
     return ScriptValue();
   }
   return definition->getConstructorForScript();
 }
 
+// https://html.spec.whatwg.org/multipage/scripting.html#look-up-a-custom-element-definition
+// At this point, what the spec calls 'is' is 'name' from desc
 CustomElementDefinition* CustomElementRegistry::definitionFor(
     const CustomElementDescriptor& desc) const {
+  // 4&5. If there is a definition in registry with name equal to is/localName
+  // Autonomous elements have the same name and local name
   CustomElementDefinition* definition = definitionForName(desc.name());
-  if (!definition)
-    return nullptr;
-  // The definition for a customized built-in element, such as
-  // <button is="my-button"> should not be provided for an
-  // autonomous element, such as <my-button>, even though the
-  // name "my-button" matches.
-  return definition->descriptor() == desc ? definition : nullptr;
+  // 4&5. and name equal to localName, return that definition
+  if (definition and definition->descriptor().localName() == desc.localName())
+    return definition;
+  // 6. Return null
+  return nullptr;
 }
 
 bool CustomElementRegistry::nameIsDefined(const AtomicString& name) const {
   return m_definitions.contains(name);
 }
 
 void CustomElementRegistry::entangle(V0CustomElementRegistrationContext* v0) {
   m_v0->add(v0);
   v0->setV1(this);
 }
@@ skipping 61 matching lines @@
   m_upgradeCandidates->remove(it);
 
   Document* document = m_owner->document();
   if (!document)
     return;
 
   sorter.sorted(elements, document);
 }
 
 }  // namespace blink