REGRESSION (r244995): Assertion failure when addEventListener to an SVGElement which...
[WebKit-https.git] / Source / WebCore / bindings / js / JSLazyEventListener.cpp
1 /*
2  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
3  *  Copyright (C) 2003-2018 Apple Inc. All Rights Reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  */
19
20 #include "config.h"
21 #include "JSLazyEventListener.h"
22
23 #include "CachedScriptFetcher.h"
24 #include "ContentSecurityPolicy.h"
25 #include "Element.h"
26 #include "Frame.h"
27 #include "JSNode.h"
28 #include "QualifiedName.h"
29 #include "SVGElement.h"
30 #include "ScriptController.h"
31 #include <JavaScriptCore/CatchScope.h>
32 #include <JavaScriptCore/FunctionConstructor.h>
33 #include <JavaScriptCore/IdentifierInlines.h>
34 #include <wtf/NeverDestroyed.h>
35 #include <wtf/RefCountedLeakCounter.h>
36 #include <wtf/StdLibExtras.h>
37 #include <wtf/WeakPtr.h>
38
39 namespace WebCore {
40 using namespace JSC;
41
42 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, eventListenerCounter, ("JSLazyEventListener"));
43
44 struct JSLazyEventListener::CreationArguments {
45     const QualifiedName& attributeName;
46     const AtomString& attributeValue;
47     Document& document;
48     WeakPtr<ContainerNode> node;
49     JSObject* wrapper;
50     bool shouldUseSVGEventName;
51 };
52
53 static const String& eventParameterName(bool shouldUseSVGEventName)
54 {
55     static NeverDestroyed<const String> eventString(MAKE_STATIC_STRING_IMPL("event"));
56     static NeverDestroyed<const String> evtString(MAKE_STATIC_STRING_IMPL("evt"));
57     return shouldUseSVGEventName ? evtString : eventString;
58 }
59
60 static TextPosition convertZeroToOne(const TextPosition& position)
61 {
62     // A JSLazyEventListener can be created with a line number of zero when it is created with
63     // a setAttribute call from JavaScript, so make the line number 1 in that case.
64     if (position == TextPosition::belowRangePosition())
65         return { };
66     return position;
67 }
68
69 JSLazyEventListener::JSLazyEventListener(CreationArguments&& arguments, const String& sourceURL, const TextPosition& sourcePosition)
70     : JSEventListener(nullptr, arguments.wrapper, true, mainThreadNormalWorld())
71     , m_functionName(arguments.attributeName.localName().string())
72     , m_eventParameterName(eventParameterName(arguments.shouldUseSVGEventName))
73     , m_code(arguments.attributeValue)
74     , m_sourceURL(sourceURL)
75     , m_sourcePosition(convertZeroToOne(sourcePosition))
76     , m_originalNode(WTFMove(arguments.node))
77 {
78 #ifndef NDEBUG
79     eventListenerCounter.increment();
80 #endif
81 }
82
83 #if !ASSERT_DISABLED
84 static inline bool isCloneInShadowTreeOfSVGUseElement(Node& originalNode, EventTarget& eventTarget)
85 {
86     if (!eventTarget.isNode())
87         return false;
88
89     auto& node = downcast<Node>(eventTarget);
90     if (!is<SVGElement>(node))
91         return false;
92
93     auto& element = downcast<SVGElement>(node);
94     if (!element.correspondingElement())
95         return false;
96
97     ASSERT(element.isInShadowTree());
98     return &originalNode == element.correspondingElement();
99 }
100
101 // This is to help find the underlying cause of <rdar://problem/24314027>.
102 void JSLazyEventListener::checkValidityForEventTarget(EventTarget& eventTarget)
103 {
104     if (eventTarget.isNode()) {
105         ASSERT(m_originalNode);
106         ASSERT(static_cast<EventTarget*>(m_originalNode.get()) == &eventTarget || isCloneInShadowTreeOfSVGUseElement(*m_originalNode, eventTarget));
107     } else
108         ASSERT(!m_originalNode);
109 }
110 #endif
111
112 JSLazyEventListener::~JSLazyEventListener()
113 {
114 #ifndef NDEBUG
115     eventListenerCounter.decrement();
116 #endif
117 }
118
119 JSObject* JSLazyEventListener::initializeJSFunction(ScriptExecutionContext& executionContext) const
120 {
121     ASSERT(is<Document>(executionContext));
122
123     auto& executionContextDocument = downcast<Document>(executionContext);
124
125     // As per the HTML specification [1], if this is an element's event handler, then document should be the
126     // element's document. The script execution context may be different from the node's document if the
127     // node's document was created by JavaScript.
128     // [1] https://html.spec.whatwg.org/multipage/webappapis.html#getting-the-current-value-of-the-event-handler
129     auto& document = m_originalNode ? m_originalNode->document() : executionContextDocument;
130     if (!document.frame())
131         return nullptr;
132
133     if (!document.contentSecurityPolicy()->allowInlineEventHandlers(m_sourceURL, m_sourcePosition.m_line))
134         return nullptr;
135
136     auto& script = document.frame()->script();
137     if (!script.canExecuteScripts(AboutToCreateEventListener) || script.isPaused())
138         return nullptr;
139
140     if (!executionContextDocument.frame())
141         return nullptr;
142     auto* globalObject = toJSDOMWindow(*executionContextDocument.frame(), isolatedWorld());
143     if (!globalObject)
144         return nullptr;
145
146     VM& vm = globalObject->vm();
147     JSLockHolder lock(vm);
148     auto scope = DECLARE_CATCH_SCOPE(vm);
149     ExecState* exec = globalObject->globalExec();
150
151     MarkedArgumentBuffer args;
152     args.append(jsNontrivialString(exec, m_eventParameterName));
153     args.append(jsStringWithCache(exec, m_code));
154     ASSERT(!args.hasOverflowed());
155
156     // We want all errors to refer back to the line on which our attribute was
157     // declared, regardless of any newlines in our JavaScript source text.
158     int overrideLineNumber = m_sourcePosition.m_line.oneBasedInt();
159
160     JSObject* jsFunction = constructFunctionSkippingEvalEnabledCheck(exec,
161         exec->lexicalGlobalObject(), args, Identifier::fromString(exec, m_functionName),
162         SourceOrigin { m_sourceURL, CachedScriptFetcher::create(document.charset()) },
163         m_sourceURL, m_sourcePosition, overrideLineNumber);
164     if (UNLIKELY(scope.exception())) {
165         reportCurrentException(exec);
166         scope.clearException();
167         return nullptr;
168     }
169
170     JSFunction* listenerAsFunction = jsCast<JSFunction*>(jsFunction);
171
172     if (m_originalNode) {
173         if (!wrapper()) {
174             // Ensure that 'node' has a JavaScript wrapper to mark the event listener we're creating.
175             // FIXME: Should pass the global object associated with the node
176             setWrapper(vm, asObject(toJS(exec, globalObject, *m_originalNode)));
177         }
178
179         // Add the event's home element to the scope
180         // (and the document, and the form - see JSHTMLElement::eventHandlerScope)
181         listenerAsFunction->setScope(vm, jsCast<JSNode*>(wrapper())->pushEventHandlerScope(exec, listenerAsFunction->scope()));
182     }
183
184     return jsFunction;
185 }
186
187 RefPtr<JSLazyEventListener> JSLazyEventListener::create(CreationArguments&& arguments)
188 {
189     if (arguments.attributeValue.isNull())
190         return nullptr;
191
192     // FIXME: We should be able to provide source information for frameless documents too (e.g. for importing nodes from XMLHttpRequest.responseXML).
193     TextPosition position;
194     String sourceURL;
195     if (Frame* frame = arguments.document.frame()) {
196         if (!frame->script().canExecuteScripts(AboutToCreateEventListener))
197             return nullptr;
198         position = frame->script().eventHandlerPosition();
199         sourceURL = arguments.document.url().string();
200     }
201
202     return adoptRef(*new JSLazyEventListener(WTFMove(arguments), sourceURL, position));
203 }
204
205 RefPtr<JSLazyEventListener> JSLazyEventListener::create(Element& element, const QualifiedName& attributeName, const AtomString& attributeValue)
206 {
207     return create({ attributeName, attributeValue, element.document(), makeWeakPtr(element), nullptr, element.isSVGElement() });
208 }
209
210 RefPtr<JSLazyEventListener> JSLazyEventListener::create(Document& document, const QualifiedName& attributeName, const AtomString& attributeValue)
211 {
212     // FIXME: This always passes false for "shouldUseSVGEventName". Is that correct for events dispatched to SVG documents?
213     // This has been this way for a long time, but became more obvious when refactoring to separate the Element and Document code paths.
214     return create({ attributeName, attributeValue, document, makeWeakPtr(document), nullptr, false });
215 }
216
217 RefPtr<JSLazyEventListener> JSLazyEventListener::create(DOMWindow& window, const QualifiedName& attributeName, const AtomString& attributeValue)
218 {
219     ASSERT(window.document());
220     auto& document = *window.document();
221     ASSERT(document.frame());
222     return create({ attributeName, attributeValue, document, nullptr, toJSDOMWindow(document.frame(), mainThreadNormalWorld()), document.isSVGDocument() });
223 }
224
225 } // namespace WebCore