Refactor LazyEventListener creation to separate Element and Document cases
[WebKit-https.git] / Source / WebCore / bindings / js / JSLazyEventListener.cpp
1 /*
2  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
3  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 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 "ContentSecurityPolicy.h"
24 #include "Frame.h"
25 #include "JSNode.h"
26 #include "ScriptController.h"
27 #include <runtime/Executable.h>
28 #include <runtime/FunctionConstructor.h>
29 #include <runtime/IdentifierInlines.h>
30 #include <wtf/NeverDestroyed.h>
31 #include <wtf/RefCountedLeakCounter.h>
32 #include <wtf/StdLibExtras.h>
33
34 using namespace JSC;
35
36 namespace WebCore {
37
38 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, eventListenerCounter, ("JSLazyEventListener"));
39
40 JSLazyEventListener::JSLazyEventListener(const String& functionName, const String& eventParameterName, const String& code, ContainerNode* node, const String& sourceURL, const TextPosition& position, JSObject* wrapper, DOMWrapperWorld& isolatedWorld)
41     : JSEventListener(0, wrapper, true, isolatedWorld)
42     , m_functionName(functionName)
43     , m_eventParameterName(eventParameterName)
44     , m_code(code)
45     , m_sourceURL(sourceURL)
46     , m_position(position)
47     , m_originalNode(node)
48 {
49     // We don't retain the original node because we assume it
50     // will stay alive as long as this handler object is around
51     // and we need to avoid a reference cycle. If JS transfers
52     // this handler to another node, initializeJSFunction will
53     // be called and then originalNode is no longer needed.
54
55     // A JSLazyEventListener can be created with a line number of zero when it is created with
56     // a setAttribute call from JavaScript, so make the line number 1 in that case.
57     if (m_position == TextPosition::belowRangePosition())
58         m_position = TextPosition::minimumPosition();
59
60     ASSERT(m_eventParameterName == "evt" || m_eventParameterName == "event");
61
62 #ifndef NDEBUG
63     eventListenerCounter.increment();
64 #endif
65 }
66
67 JSLazyEventListener::~JSLazyEventListener()
68 {
69 #ifndef NDEBUG
70     eventListenerCounter.decrement();
71 #endif
72 }
73
74 JSObject* JSLazyEventListener::initializeJSFunction(ScriptExecutionContext* executionContext) const
75 {
76     ASSERT(is<Document>(executionContext));
77     if (!executionContext)
78         return nullptr;
79
80     ASSERT(!m_code.isNull());
81     ASSERT(!m_eventParameterName.isNull());
82     if (m_code.isNull() || m_eventParameterName.isNull())
83         return nullptr;
84
85     Document& document = downcast<Document>(*executionContext);
86
87     if (!document.frame())
88         return nullptr;
89
90     if (!document.contentSecurityPolicy()->allowInlineEventHandlers(m_sourceURL, m_position.m_line))
91         return nullptr;
92
93     ScriptController& script = document.frame()->script();
94     if (!script.canExecuteScripts(AboutToExecuteScript) || script.isPaused())
95         return nullptr;
96
97     JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(executionContext, isolatedWorld());
98     if (!globalObject)
99         return nullptr;
100
101     ExecState* exec = globalObject->globalExec();
102
103     MarkedArgumentBuffer args;
104     args.append(jsNontrivialString(exec, m_eventParameterName));
105     args.append(jsStringWithCache(exec, m_code));
106
107     // We want all errors to refer back to the line on which our attribute was
108     // declared, regardless of any newlines in our JavaScript source text.
109     int overrideLineNumber = m_position.m_line.oneBasedInt();
110
111     JSObject* jsFunction = constructFunctionSkippingEvalEnabledCheck(
112         exec, exec->lexicalGlobalObject(), args, Identifier::fromString(exec, m_functionName),
113         m_sourceURL, m_position, overrideLineNumber);
114
115     if (exec->hadException()) {
116         reportCurrentException(exec);
117         exec->clearException();
118         return nullptr;
119     }
120
121     JSFunction* listenerAsFunction = jsCast<JSFunction*>(jsFunction);
122
123     if (m_originalNode) {
124         if (!wrapper()) {
125             // Ensure that 'node' has a JavaScript wrapper to mark the event listener we're creating.
126             JSLockHolder lock(exec);
127             // FIXME: Should pass the global object associated with the node
128             setWrapper(exec->vm(), asObject(toJS(exec, globalObject, m_originalNode)));
129         }
130
131         // Add the event's home element to the scope
132         // (and the document, and the form - see JSHTMLElement::eventHandlerScope)
133         listenerAsFunction->setScope(exec->vm(), jsCast<JSNode*>(wrapper())->pushEventHandlerScope(exec, listenerAsFunction->scope()));
134     }
135     return jsFunction;
136 }
137
138 static const String& eventParameterName(bool isSVGEvent)
139 {
140     static NeverDestroyed<const String> eventString(ASCIILiteral("event"));
141     static NeverDestroyed<const String> evtString(ASCIILiteral("evt"));
142     return isSVGEvent ? evtString : eventString;
143 }
144
145 struct JSLazyEventListener::CreationArguments {
146     const QualifiedName& attributeName;
147     const AtomicString& attributeValue;
148     Document& document;
149     ContainerNode* node;
150     JSC::JSObject* wrapper;
151     bool shouldUseSVGEventName;
152 };
153
154 RefPtr<JSLazyEventListener> JSLazyEventListener::create(const CreationArguments& arguments)
155 {
156     if (arguments.attributeValue.isNull())
157         return nullptr;
158
159     // FIXME: We should be able to provide source information for frameless documents too (e.g. for importing nodes from XMLHttpRequest.responseXML).
160     TextPosition position;
161     String sourceURL;
162     if (Frame* frame = arguments.document.frame()) {
163         if (!frame->script().canExecuteScripts(AboutToExecuteScript))
164             return nullptr;
165         position = frame->script().eventHandlerPosition();
166         sourceURL = arguments.document.url().string();
167     }
168
169     return adoptRef(*new JSLazyEventListener(arguments.attributeName.localName().string(),
170         eventParameterName(arguments.shouldUseSVGEventName), arguments.attributeValue,
171         arguments.node, sourceURL, position, arguments.wrapper, mainThreadNormalWorld()));
172 }
173
174 RefPtr<JSLazyEventListener> JSLazyEventListener::create(Element& element, const QualifiedName& attributeName, const AtomicString& attributeValue)
175 {
176     return create({ attributeName, attributeValue, element.document(), &element, nullptr, element.isSVGElement() });
177 }
178
179 RefPtr<JSLazyEventListener> JSLazyEventListener::create(Document& document, const QualifiedName& attributeName, const AtomicString& attributeValue)
180 {
181     // FIXME: This always passes false for "shouldUseSVGEventName". Is that correct for events dispatched to SVG documents?
182     // This has been this way for a long time, but became more obvious when refactoring to separate the Element and Document code paths.
183     return create({ attributeName, attributeValue, document, &document, nullptr, false });
184 }
185
186 RefPtr<JSLazyEventListener> JSLazyEventListener::create(DOMWindow& window, const QualifiedName& attributeName, const AtomicString& attributeValue)
187 {
188     ASSERT(window.document());
189     auto& document = *window.document();
190     ASSERT(document.frame());
191     return create({ attributeName, attributeValue, document, nullptr, toJSDOMWindow(document.frame(), mainThreadNormalWorld()), document.isSVGDocument() });
192 }
193
194 } // namespace WebCore