Make custom elements work in HTML imports

third_party/WebKit/Source/core/dom/custom/CustomElementDefinition.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/CustomElementDefinition.h"
 
 #include "core/dom/Attr.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/dom/custom/CustomElementAdoptedCallbackReaction.h"
@@ skipping 37 matching lines @@
     // 6.1.4. If result's attribute list is not empty, then throw a NotSupportedError.
     if (element->hasAttributes())
         return "The result must not have attributes";
     // 6.1.5. If result has children, then throw a NotSupportedError.
     if (element->hasChildren())
         return "The result must not have children";
     // 6.1.6. If result's parent is not null, then throw a NotSupportedError.
     if (element->parentNode())
         return "The result must not have a parent";
     // 6.1.7. If result's node document is not document, then throw a NotSupportedError.
-    if (&element->document() != &document)
+    if (&element->document() != &document

[dominicc (has gone to gerrit), 2016/08/22 08:07:36]

I have two problems with this.

First, you write a DCHECK in the CustomElementsRegistry constructor that implies
the main document's context document is the main document. If that's true, then
line 58 is redundant.

Second, this still seems wrong. Why can we not require that d.createElement
returns elements in d, whether d is an import document or not?

[kochi, 2016/08/22 12:01:59]

CustomElementsRegistry constructor and constructor here (a custom element's
constructor) run in different context, right?  CustomElementRegistry is a
property of window, while custom element's constructor can run in the context
of main document, or imported document.

The original DCHECK in CustomElementsRegistry's constructor was to make sure
the registry is created for the main document, not for any imported documents.
(and I think that is no longer necessary.)
Looks like I misunderstood, that 
document.createElement('a-a') -> el.ownerDocument = document
importDoc.createElement('a-a') -> el.ownerDocument = importDoc

but now the latter is el.ownerDocument = document.
I'm looking into this.  (maybe a bug?  importDoc.createElement('div') will
make div with ownerDocument = importDoc.)

+        && element->document().contextDocument() != document.contextDocument()) {
         return "The result must be in the same document";
+    }
     // 6.1.8. If result's namespace is not the HTML namespace, then throw a NotSupportedError.
     if (element->namespaceURI() != HTMLNames::xhtmlNamespaceURI)
         return "The result must have HTML namespace";
     // 6.1.9. If result's local name is not equal to localName, then throw a NotSupportedError.
     if (element->localName() != tagName.localName())
         return "The result must have the same localName";
     return String();
 }
 
 void CustomElementDefinition::checkConstructorResult(Element* element,
@@ skipping 115 matching lines @@
         element->synchronizeAttribute(name);
     for (const auto& attribute : element->attributesWithoutUpdate()) {
         if (hasAttributeChangedCallback(attribute.name())) {
             enqueueAttributeChangedCallback(element, attribute.name(),
                 nullAtom, attribute.value());
         }
     }
 }
 
 } // namespace blink