d52a9f295a9567abeb944326be16b3d3293c0d9b
[WebKit-https.git] / Source / WebCore / bindings / js / JSCustomElementInterface.cpp
1 /*
2  * Copyright (C) 2013 Google Inc. All rights reserved.
3  * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27
28 #include "config.h"
29 #include "JSCustomElementInterface.h"
30
31 #include "DOMWrapperWorld.h"
32 #include "HTMLUnknownElement.h"
33 #include "JSDOMBinding.h"
34 #include "JSDOMConvertNullable.h"
35 #include "JSDOMConvertStrings.h"
36 #include "JSDOMGlobalObject.h"
37 #include "JSElement.h"
38 #include "JSHTMLElement.h"
39 #include "JSMainThreadExecState.h"
40 #include "JSMainThreadExecStateInstrumentation.h"
41 #include "ScriptExecutionContext.h"
42 #include <heap/WeakInlines.h>
43 #include <runtime/JSLock.h>
44
45 using namespace JSC;
46
47 namespace WebCore {
48
49 JSCustomElementInterface::JSCustomElementInterface(const QualifiedName& name, JSObject* constructor, JSDOMGlobalObject* globalObject)
50     : ActiveDOMCallback(globalObject->scriptExecutionContext())
51     , m_name(name)
52     , m_constructor(constructor)
53     , m_isolatedWorld(globalObject->world())
54 {
55 }
56
57 JSCustomElementInterface::~JSCustomElementInterface()
58 {
59 }
60
61 static RefPtr<Element> constructCustomElementSynchronously(Document&, VM&, ExecState&, JSObject* constructor, const AtomicString& localName);
62
63 Ref<Element> JSCustomElementInterface::constructElementWithFallback(Document& document, const AtomicString& localName)
64 {
65     if (auto element = tryToConstructCustomElement(document, localName))
66         return element.releaseNonNull();
67
68     auto element = HTMLUnknownElement::create(QualifiedName(nullAtom, localName, HTMLNames::xhtmlNamespaceURI), document);
69     element->setIsCustomElementUpgradeCandidate();
70     element->setIsFailedCustomElement(*this);
71
72     return WTFMove(element);
73 }
74
75 Ref<Element> JSCustomElementInterface::constructElementWithFallback(Document& document, const QualifiedName& name)
76 {
77     if (auto element = tryToConstructCustomElement(document, name.localName())) {
78         if (name.prefix() != nullAtom)
79             element->setPrefix(name.prefix());
80         return element.releaseNonNull();
81     }
82
83     auto element = HTMLUnknownElement::create(name, document);
84     element->setIsCustomElementUpgradeCandidate();
85     element->setIsFailedCustomElement(*this);
86
87     return WTFMove(element);
88 }
89
90 RefPtr<Element> JSCustomElementInterface::tryToConstructCustomElement(Document& document, const AtomicString& localName)
91 {
92     if (!canInvokeCallback())
93         return nullptr;
94
95     Ref<JSCustomElementInterface> protectedThis(*this);
96
97     VM& vm = m_isolatedWorld->vm();
98     JSLockHolder lock(vm);
99     auto scope = DECLARE_CATCH_SCOPE(vm);
100
101     if (!m_constructor)
102         return nullptr;
103
104     ASSERT(&document == scriptExecutionContext());
105     auto& state = *document.execState();
106     auto element = constructCustomElementSynchronously(document, vm, state, m_constructor.get(), localName);
107     ASSERT(!!scope.exception() == !element);
108     if (!element) {
109         auto* exception = scope.exception();
110         scope.clearException();
111         reportException(&state, exception);
112         return nullptr;
113     }
114
115     return element;
116 }
117
118 // https://dom.spec.whatwg.org/#concept-create-element
119 // 6. 1. If the synchronous custom elements flag is set
120 static RefPtr<Element> constructCustomElementSynchronously(Document& document, VM& vm, ExecState& state, JSObject* constructor, const AtomicString& localName)
121 {
122     auto scope = DECLARE_THROW_SCOPE(vm);
123     ConstructData constructData;
124     ConstructType constructType = constructor->methodTable()->getConstructData(constructor, constructData);
125     if (constructType == ConstructType::None) {
126         ASSERT_NOT_REACHED();
127         return nullptr;
128     }
129
130     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionConstruct(&document, constructType, constructData);
131     MarkedArgumentBuffer args;
132     JSValue newElement = construct(&state, constructor, constructType, constructData, args);
133     InspectorInstrumentation::didCallFunction(cookie, &document);
134     RETURN_IF_EXCEPTION(scope, nullptr);
135
136     ASSERT(!newElement.isEmpty());
137     HTMLElement* wrappedElement = JSHTMLElement::toWrapped(vm, newElement);
138     if (!wrappedElement) {
139         throwTypeError(&state, scope, ASCIILiteral("The result of constructing a custom element must be a HTMLElement"));
140         return nullptr;
141     }
142
143     if (wrappedElement->hasAttributes()) {
144         throwNotSupportedError(state, scope, ASCIILiteral("A newly constructed custom element must not have attributes"));
145         return nullptr;
146     }
147     if (wrappedElement->hasChildNodes()) {
148         throwNotSupportedError(state, scope, ASCIILiteral("A newly constructed custom element must not have child nodes"));
149         return nullptr;
150     }
151     if (wrappedElement->parentNode()) {
152         throwNotSupportedError(state, scope, ASCIILiteral("A newly constructed custom element must not have a parent node"));
153         return nullptr;
154     }
155     if (&wrappedElement->document() != &document) {
156         throwNotSupportedError(state, scope, ASCIILiteral("A newly constructed custom element belongs to a wrong docuemnt"));
157         return nullptr;
158     }
159     ASSERT(wrappedElement->namespaceURI() == HTMLNames::xhtmlNamespaceURI);
160     if (wrappedElement->localName() != localName) {
161         throwNotSupportedError(state, scope, ASCIILiteral("A newly constructed custom element belongs to a wrong docuemnt"));
162         return nullptr;
163     }
164
165     return wrappedElement;
166 }
167
168 void JSCustomElementInterface::upgradeElement(Element& element)
169 {
170     ASSERT(element.tagQName() == name());
171     ASSERT(element.isCustomElementUpgradeCandidate());
172     if (!canInvokeCallback())
173         return;
174
175     Ref<JSCustomElementInterface> protectedThis(*this);
176     VM& vm = m_isolatedWorld->vm();
177     JSLockHolder lock(vm);
178     auto scope = DECLARE_THROW_SCOPE(vm);
179
180     if (!m_constructor)
181         return;
182
183     ScriptExecutionContext* context = scriptExecutionContext();
184     if (!context)
185         return;
186     ASSERT(context->isDocument());
187     JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(context, m_isolatedWorld);
188     ExecState* state = globalObject->globalExec();
189     RETURN_IF_EXCEPTION(scope, void());
190
191     ConstructData constructData;
192     ConstructType constructType = m_constructor->methodTable()->getConstructData(m_constructor.get(), constructData);
193     if (constructType == ConstructType::None) {
194         ASSERT_NOT_REACHED();
195         return;
196     }
197
198     CustomElementReactionQueue::enqueuePostUpgradeReactions(element);
199
200     m_constructionStack.append(&element);
201
202     MarkedArgumentBuffer args;
203     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionConstruct(context, constructType, constructData);
204     JSValue returnedElement = construct(state, m_constructor.get(), constructType, constructData, args);
205     InspectorInstrumentation::didCallFunction(cookie, context);
206
207     m_constructionStack.removeLast();
208
209     if (UNLIKELY(scope.exception())) {
210         element.setIsFailedCustomElement(*this);
211         reportException(state, scope.exception());
212         return;
213     }
214
215     Element* wrappedElement = JSElement::toWrapped(vm, returnedElement);
216     if (!wrappedElement || wrappedElement != &element) {
217         element.setIsFailedCustomElement(*this);
218         reportException(state, createDOMException(state, INVALID_STATE_ERR, "Custom element constructor failed to upgrade an element"));
219         return;
220     }
221     element.setIsDefinedCustomElement(*this);
222 }
223
224 void JSCustomElementInterface::invokeCallback(Element& element, JSObject* callback, const WTF::Function<void(ExecState*, JSDOMGlobalObject*, MarkedArgumentBuffer&)>& addArguments)
225 {
226     if (!canInvokeCallback())
227         return;
228
229     auto* context = scriptExecutionContext();
230     if (!context)
231         return;
232
233     Ref<JSCustomElementInterface> protectedThis(*this);
234     JSLockHolder lock(m_isolatedWorld->vm());
235
236     ASSERT(context);
237     ASSERT(context->isDocument());
238     JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(context, m_isolatedWorld);
239     ExecState* state = globalObject->globalExec();
240
241     JSObject* jsElement = asObject(toJS(state, globalObject, element));
242
243     CallData callData;
244     CallType callType = callback->methodTable()->getCallData(callback, callData);
245     ASSERT(callType != CallType::None);
246
247     MarkedArgumentBuffer args;
248     addArguments(state, globalObject, args);
249
250     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionCall(context, callType, callData);
251
252     NakedPtr<JSC::Exception> exception;
253     JSMainThreadExecState::call(state, callback, callType, callData, jsElement, args, exception);
254
255     InspectorInstrumentation::didCallFunction(cookie, context);
256
257     if (exception)
258         reportException(state, exception);
259 }
260
261 void JSCustomElementInterface::setConnectedCallback(JSC::JSObject* callback)
262 {
263     m_connectedCallback = callback;
264 }
265
266 void JSCustomElementInterface::invokeConnectedCallback(Element& element)
267 {
268     invokeCallback(element, m_connectedCallback.get());
269 }
270
271 void JSCustomElementInterface::setDisconnectedCallback(JSC::JSObject* callback)
272 {
273     m_disconnectedCallback = callback;
274 }
275
276 void JSCustomElementInterface::invokeDisconnectedCallback(Element& element)
277 {
278     invokeCallback(element, m_disconnectedCallback.get());
279 }
280
281 void JSCustomElementInterface::setAdoptedCallback(JSC::JSObject* callback)
282 {
283     m_adoptedCallback = callback;
284 }
285
286 void JSCustomElementInterface::invokeAdoptedCallback(Element& element, Document& oldDocument, Document& newDocument)
287 {
288     invokeCallback(element, m_adoptedCallback.get(), [&](ExecState* state, JSDOMGlobalObject* globalObject, MarkedArgumentBuffer& args) {
289         args.append(toJS(state, globalObject, oldDocument));
290         args.append(toJS(state, globalObject, newDocument));
291     });
292 }
293
294 void JSCustomElementInterface::setAttributeChangedCallback(JSC::JSObject* callback, const Vector<String>& observedAttributes)
295 {
296     m_attributeChangedCallback = callback;
297     m_observedAttributes.clear();
298     for (auto& name : observedAttributes)
299         m_observedAttributes.add(name);
300 }
301
302 void JSCustomElementInterface::invokeAttributeChangedCallback(Element& element, const QualifiedName& attributeName, const AtomicString& oldValue, const AtomicString& newValue)
303 {
304     invokeCallback(element, m_attributeChangedCallback.get(), [&](ExecState* state, JSDOMGlobalObject*, MarkedArgumentBuffer& args) {
305         args.append(toJS<IDLDOMString>(*state, attributeName.localName()));
306         args.append(toJS<IDLNullable<IDLDOMString>>(*state, oldValue));
307         args.append(toJS<IDLNullable<IDLDOMString>>(*state, newValue));
308         args.append(toJS<IDLNullable<IDLDOMString>>(*state, attributeName.namespaceURI()));
309     });
310 }
311
312 void JSCustomElementInterface::didUpgradeLastElementInConstructionStack()
313 {
314     m_constructionStack.last() = nullptr;
315 }
316
317 } // namespace WebCore