Make custom elements work in HTML imports

third_party/WebKit/Source/core/dom/custom/CustomElementUpgradeSorter.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/CustomElementUpgradeSorter.h"
 
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/Node.h"
 #include "core/dom/shadow/ShadowRoot.h"
+#include "core/html/HTMLLinkElement.h"
+#include "core/html/imports/HTMLImportChild.h"
+#include "core/html/imports/HTMLImportLoader.h"
 
 namespace blink {
 
 CustomElementUpgradeSorter::CustomElementUpgradeSorter()
     : m_elements(new HeapHashSet<Member<Element>>())
     , m_parentChildMap(new ParentChildMap())
 {
 }
 
+static HTMLLinkElement* getLinkElement(Document* document)
+{
+    DCHECK(document);
+    HTMLImportLoader* loader = document->importLoader();
+    if (!loader)
+        return nullptr;
+
+    return loader->firstImport()->link();
+}
+
+CustomElementUpgradeSorter::AddResult CustomElementUpgradeSorter::addToParentChildMap(
+    Node* parent,
+    Node* child)
+{
+    ParentChildMap::iterator it = m_parentChildMap->find(parent);
+    if (it != m_parentChildMap->end()) {
+        it->value.add(child);
+        // The entry for the parent exists; so must its parents.
+        return kParentAlreadyExistsInMap;
+    }
+    ParentChildMap::AddResult result =
+        m_parentChildMap->add(parent, HeapHashSet<Member<Node>>());
+    result.storedValue->value.add(child);
+    return kParentAddedToMap;
+}
+
 void CustomElementUpgradeSorter::add(Element* element)
 {
     m_elements->add(element);
 
-    for (Node* n = element, *parent = n->parentOrShadowHostNode();
-        parent;
-        n = parent, parent = parent->parentOrShadowHostNode()) {
+    // Note: handling of |parent| here is tricky; At the first iteration
+    // |parent| can never be nullptr because the input is |element| and this

[dominicc (has gone to gerrit), 2016/08/22 12:05:58]

Actually this isn't true; the parent can be nullptr if the element is
disconnected. So it is subtler than this.

You need to comment why it's OK to use a simpler way to get the "parent" here,
than on lines 62-74. The reason isn't about whether the parent is null.

[kochi, 2016/08/24 11:26:03]

Refactored this code and I think the loop look better now.

+    // loop traverses up to document. Therefore the <link> check in the middle
+    // of the loop will be run whenever a document is found.
+    for (Node* n = element, *parent = n->parentOrShadowHostNode(); parent;) {
+        if (addToParentChildMap(parent, n) == kParentAlreadyExistsInMap)
+            break;
 
-        ParentChildMap::iterator it = m_parentChildMap->find(parent);
-        if (it == m_parentChildMap->end()) {
-            ParentChildMap::AddResult result =
-                m_parentChildMap->add(parent, HeapHashSet<Member<Node>>());
-            result.storedValue->value.add(n);
-        } else {
-            it->value.add(n);
-            // The entry for the parent exists; so must its parents.
-            break;
+        n = parent;
+        parent = parent->parentOrShadowHostNode();
+
+        // Check if this is an imported document, and if it is, register its
+        // corresponding <link rel="import"> element as its parent.
+        if (!parent && n->isDocumentNode()) {
+            Document* d = toDocument(n);
+            Element* link = getLinkElement(d);
+            if (!link || addToParentChildMap(link, n) == kParentAlreadyExistsInMap)
+                break;
+
+            n = link;
+            parent = link->parentOrShadowHostNode();
         }
     }
 }
 
 void CustomElementUpgradeSorter::visit(
     HeapVector<Member<Element>>* result,
     ChildSet& children,
     const ChildSet::iterator& it)
 {
     if (it == children.end())
@@ skipping 34 matching lines @@
         visit(result, children, children.find(e));
     }
 
     if (children.size() == 1)
         visit(result, children, children.begin());
 
     DCHECK(children.isEmpty());
 }
 
 } // namespace blink