Make Custom Elements V1 work in HTML imports documents

third_party/WebKit/Source/core/dom/custom/CustomElement.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/CustomElement.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/QualifiedName.h"
 #include "core/dom/custom/CEReactionsScope.h"
 #include "core/dom/custom/CustomElementDefinition.h"
 #include "core/dom/custom/CustomElementReactionStack.h"
 #include "core/dom/custom/CustomElementsRegistry.h"
 #include "core/dom/custom/V0CustomElement.h"
 #include "core/dom/custom/V0CustomElementRegistrationContext.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/html/HTMLElement.h"
 #include "platform/text/Character.h"
 #include "wtf/text/AtomicStringHash.h"
 
 namespace blink {
 
 CustomElementsRegistry* CustomElement::registry(const Element& element)
 {
     return registry(element.document());
 }
 
 CustomElementsRegistry* CustomElement::registry(const Document& document)
 {
-    if (LocalDOMWindow* window = document.domWindow())
-        return window->customElements();
+    if (Document* contextDocument = const_cast<Document&>(document).contextDocument()) {

[dominicc (has gone to gerrit), 2016/07/13 06:12:30]

FYI haraken says in Q4 that Blink will be able to run JavaScript in detached
contexts. What we have today means elements will not run callbacks if their
document is detached. We may need to have elements point to their definitions or
something.

Just a "heads up" that something like this is coming--nothing to do in this
patch.

+        if (LocalDOMWindow* window = contextDocument->domWindow())
+            return window->customElements();
+    }
     return nullptr;
 }
 
+FrameHost* CustomElement::contextFrameHost(const Element& element)
+{
+    if (Document* contextDocument = element.document().contextDocument())
+        return contextDocument->frameHost();
+    return nullptr;
+}
+
 CustomElementDefinition* CustomElement::definitionForElement(const Element& element)
 {
     if (CustomElementsRegistry* registry = CustomElement::registry(element))
         return registry->definitionForName(element.localName());
     return nullptr;
 }
 
 bool CustomElement::isValidName(const AtomicString& name)
 {
     if (!name.length() || name[0] < 'a' || name[0] > 'z')
@@ skipping 26 matching lines @@
         hyphenContainingElementNames.add("font-face-name");
         hyphenContainingElementNames.add("missing-glyph");
     }
 
     return !hyphenContainingElementNames.contains(name);
 }
 
 bool CustomElement::shouldCreateCustomElement(Document& document, const AtomicString& localName)
 {
     return RuntimeEnabledFeatures::customElementsV1Enabled()
-        && document.frame() && isValidName(localName);
+        && document.contextDocument() && document.contextDocument()->frame()
+        && isValidName(localName);
 }
 
 bool CustomElement::shouldCreateCustomElement(Document& document, const QualifiedName& tagName)
 {
     return shouldCreateCustomElement(document, tagName.localName())
         && tagName.namespaceURI() == HTMLNames::xhtmlNamespaceURI;
 }
 
 static CustomElementDefinition* definitionForName(const Document& document, const QualifiedName& name)
 {
@@ skipping 77 matching lines @@
 
     // If the custom element reactions stack is not empty, then
     // Add element to the current element queue.
     if (CEReactionsScope* current = CEReactionsScope::current()) {
         current->enqueueToCurrentQueue(element, reaction);
         return;
     }
 
     // If the custom element reactions stack is empty, then
     // Add element to the backup element queue.
-    element->document().frameHost()->customElementReactionStack()
+    contextFrameHost(*element)->customElementReactionStack()
         .enqueueToBackupQueue(element, reaction);
 }
 
 void CustomElement::enqueueConnectedCallback(Element* element)
 {
     DCHECK_EQ(element->getCustomElementState(), CustomElementState::Custom);
     CustomElementDefinition* definition = definitionForElement(*element);
     if (definition->hasConnectedCallback())
         definition->enqueueConnectedCallback(element);
 }
@@ skipping 27 matching lines @@
     CustomElementsRegistry* registry = CustomElement::registry(*element);
     if (!registry)
         return;
     if (CustomElementDefinition* definition = registry->definitionForName(element->localName()))
         definition->enqueueUpgradeReaction(element);
     else
         registry->addCandidate(element);
 }
 
 } // namespace blink