Make custom elements work in HTML imports

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"
@@ skipping 61 matching lines @@
         document ? document->registrationContext() : nullptr)
         registry->entangle(v0);
     return registry;
 }
 
 CustomElementsRegistry::CustomElementsRegistry(const LocalDOMWindow* owner)
     : m_owner(owner)
     , m_v0 (new V0RegistrySet())
     , m_upgradeCandidates(new UpgradeCandidateMap())
 {
+    // !contextDocument() just for unit testing.

[dominicc (has gone to gerrit), 2016/08/19 04:54:11]

Can you explain what you're thinking here? Which unit tests don't have document
=== context document? I think this changed with the switch from
CustomElementsRegistry taking the document to taking the window.

[kochi, 2016/08/19 10:51:48]

Will update the comment.

[kochi, 2016/08/22 07:37:34]

Looks the comment is obsolete, and the latter condition is not necessary.

+    DCHECK(m_owner->document() == m_owner->document()->contextDocument()
+        || !m_owner->document()->contextDocument());
 }
 
 DEFINE_TRACE(CustomElementsRegistry)
 {
     visitor->trace(m_definitions);
     visitor->trace(m_owner);
     visitor->trace(m_v0);
     visitor->trace(m_upgradeCandidates);
     visitor->trace(m_whenDefinedPromiseMap);
 }
@@ skipping 135 matching lines @@
 }
 
 CustomElementDefinition* CustomElementsRegistry::definitionForName(
     const AtomicString& name) const
 {
     return m_definitions.get(name);
 }
 
 void CustomElementsRegistry::addCandidate(Element* candidate)
 {
+    // !contextDocument() just for unit testing.
+    DCHECK(candidate->document().contextDocument() == m_owner->document()
+        || !candidate->document().contextDocument());
+
     const AtomicString& name = candidate->localName();
     if (nameIsDefined(name) || v0NameIsDefined(name))
         return;
     UpgradeCandidateMap::iterator it = m_upgradeCandidates->find(name);
     UpgradeCandidateSet* set;
     if (it != m_upgradeCandidates->end()) {
         set = it->value;
     } else {
         set = m_upgradeCandidates->add(name, new UpgradeCandidateSet())
             .storedValue
@@ skipping 15 matching lines @@
         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();
 }
 
+using ElementsInDocument = HeapVector<Member<Element>>;
+using ElementsDocumentMap = HeapHashMap<Document*, ElementsInDocument>;
+
+static void addToImports(ElementsDocumentMap& imports, Element* element)
+{
+    Document* document = &element->document();
+    const auto& it = imports.find(document);
+    ElementsInDocument* list;
+    if (it != imports.end()) {
+        list = &it->value;
+    } else {
+        list = &imports.add(document, ElementsInDocument())
+            .storedValue->value;
+    }
+    list->append(element);
+}
+
+static void collectFromImports(ElementsDocumentMap& imports, HeapVector<Member<Element>>* elements)
+{
+    for (const auto& it : imports) {
+        CustomElementUpgradeSorter sorter;
+        for (Element* element : it.value)
+            sorter.add(element);
+        sorter.sorted(elements, it.key);
+    }
+}
+
 void CustomElementsRegistry::collectCandidates(
     const CustomElementDescriptor& desc,
     HeapVector<Member<Element>>* elements)
 {
     UpgradeCandidateMap::iterator it = m_upgradeCandidates->find(desc.name());
     if (it == m_upgradeCandidates->end())
         return;
+
+    ElementsDocumentMap imports;
     CustomElementUpgradeSorter sorter;
     for (Element* element : *it.get()->value) {
         if (!element || !desc.matches(*element))
             continue;
-        sorter.add(element);
+
+        // Group elements by document if they are in import documents.
+        Document& document = element->document();
+        if (document == m_owner->document())
+            sorter.add(element);
+        else if (document.contextDocument() == m_owner->document())
+            addToImports(imports, element);

[dominicc (has gone to gerrit), 2016/08/19 04:54:11]

Why not just put them all in the sorter? Sorter can handle having elements in
random documents added to it. Then you could simplify this code a lot. You just
need to have the sorter for imported documents treat them like children of the
main document. Maybe you could put them in import tree order.

[kochi, 2016/08/22 07:37:34]

Done.

     }
 
     m_upgradeCandidates->remove(it);
 
-    Document* document = m_owner->document();
-    if (!document)
-        return;
+    // Document* document = m_owner->document();

[dominicc (has gone to gerrit), 2016/08/19 04:54:11]

Let's not commit commented-out code like this.

[kochi, 2016/08/19 10:51:48]

Done.  This was a tentative commentout and unintentional.

+    // if (!document)
+    //     return;
 
-    sorter.sorted(elements, document);
+    // If there were elements from import documents, put them first.
+    if (!imports.isEmpty())
+        collectFromImports(imports, elements);
+
+    sorter.sorted(elements, m_owner->document());
 }
 
 } // namespace blink