Introduce CustomElementRegistry#whenDefined() method

third_party/WebKit/Source/core/dom/custom/CustomElementsRegistry.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/CustomElementsRegistry.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"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementRegistrationOptions.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/custom/CEReactionsScope.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/dom/custom/CustomElementDefinition.h"
 #include "core/dom/custom/CustomElementDefinitionBuilder.h"
 #include "core/dom/custom/CustomElementDescriptor.h"
 #include "core/dom/custom/CustomElementUpgradeReaction.h"
 #include "core/dom/custom/CustomElementUpgradeSorter.h"
 #include "core/dom/custom/V0CustomElementRegistrationContext.h"
 #include "wtf/Allocator.h"
 
 namespace blink {
 
+namespace {
+// Returns true if |name| is invalid.
+bool throwIfInvalidName(
+    const AtomicString& name,
+    ExceptionState& exceptionState)
+{
+    if (CustomElement::isValidName(name))
+        return false;
+    exceptionState.throwDOMException(
+        SyntaxError,
+        "\"" + name + "\" is not a valid custom element name");
+    return true;
+}
+} // namespace

[dominicc (has gone to gerrit), 2016/06/10 06:20:57]

Blank lines before }, after namespace { maybe? That seems to be practice. Why do
this namespace thing and not static in blink::?

[yosin_UTC9, 2016/06/10 07:52:28]

Done.
Use static function instead of anonymous namespace, since there is only one
function.

+
 class CustomElementsRegistry::NameIsBeingDefined final {
     STACK_ALLOCATED();
     DISALLOW_IMPLICIT_CONSTRUCTORS(NameIsBeingDefined);
 public:
     NameIsBeingDefined(
         CustomElementsRegistry* registry,
         const AtomicString& name)
         : m_registry(registry)
         , m_name(name)
     {
@@ skipping 51 matching lines @@
 // http://w3c.github.io/webcomponents/spec/custom/#dfn-element-definition
 void CustomElementsRegistry::define(
     const AtomicString& name,
     CustomElementDefinitionBuilder& builder,
     const ElementRegistrationOptions& options,
     ExceptionState& exceptionState)
 {
     if (!builder.checkConstructorIntrinsics())
         return;
 
-    if (!CustomElement::isValidName(name)) {
-        exceptionState.throwDOMException(
-            SyntaxError,
-            "\"" + name + "\" is not a valid custom element name");
+    if (throwIfInvalidName(name, exceptionState))
         return;
-    }
 
     if (m_namesBeingDefined.contains(name)) {
         exceptionState.throwDOMException(
             NotSupportedError,
             "this name is already being defined in this registry");
         return;
     }
     NameIsBeingDefined defining(this, name);
 
     if (nameIsDefined(name) || v0NameIsDefined(name)) {
@@ skipping 37 matching lines @@
     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)
         CustomElement::enqueueUpgradeReaction(candidate, definition);
 
-    // TODO(dominicc): Implement steps:
-    // 20: when-defined promise processing
+    // 19: when-defined promise processing
+    const auto& entry = m_whenDefinedPromiseMap.find(name);
+    if (entry == m_whenDefinedPromiseMap.end())
+        return;
+    entry->value->resolve();
+    m_whenDefinedPromiseMap.remove(entry);
 }
 
 // https://html.spec.whatwg.org/multipage/scripting.html#dom-customelementsregistry-get
 ScriptValue CustomElementsRegistry::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();
@@ skipping 34 matching lines @@
     if (it != m_upgradeCandidates->end()) {
         set = it->value;
     } else {
         set = m_upgradeCandidates->add(name, new UpgradeCandidateSet())
             .storedValue
             ->value;
     }
     set->add(candidate);
 }
 
+// https://html.spec.whatwg.org/multipage/scripting.html#dom-customelementsregistry-whendefined
+ScriptPromise CustomElementsRegistry::whenDefined(
+    ScriptState* scriptState,
+    const AtomicString& name,
+    ExceptionState& exceptionState)
+{
+    if (throwIfInvalidName(name, exceptionState))
+        return ScriptPromise();
+    CustomElementDefinition* definition = definitionForName(name);
+    if (definition)
+        return ScriptPromise::castUndefined(scriptState);
+    ScriptPromiseResolver* resolver = m_whenDefinedPromiseMap.get(name);
+    if (resolver)
+        return resolver->promise();
+    ScriptPromiseResolver* newResolver =
+        ScriptPromiseResolver::create(scriptState);
+    m_whenDefinedPromiseMap.add(name, newResolver);
+    return newResolver->promise();
+}
+
 void CustomElementsRegistry::collectCandidates(
     const CustomElementDescriptor& desc,
     HeapVector<Member<Element>>* elements)
 {
     UpgradeCandidateMap::iterator it = m_upgradeCandidates->find(desc.name());
     if (it == m_upgradeCandidates->end())
         return;
     CustomElementUpgradeSorter sorter;
     for (Element* element : *it.get()->value) {
         if (!element || !desc.matches(*element))
             continue;
         sorter.add(element);
     }
 
     m_upgradeCandidates->remove(it);
     sorter.sorted(elements, m_document.get());
 }
 
 } // namespace blink