Replace 0 and NULL with nullptr in WebCore/dom.
[WebKit-https.git] / Source / WebCore / dom / ScriptElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
6  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "ScriptElement.h"
26
27 #include "CachedResourceLoader.h"
28 #include "CachedResourceRequest.h"
29 #include "CachedScript.h"
30 #include "ContentSecurityPolicy.h"
31 #include "CrossOriginAccessControl.h"
32 #include "CurrentScriptIncrementer.h"
33 #include "Event.h"
34 #include "Frame.h"
35 #include "FrameLoader.h"
36 #include "HTMLNames.h"
37 #include "HTMLParserIdioms.h"
38 #include "IgnoreDestructiveWriteCountIncrementer.h"
39 #include "MIMETypeRegistry.h"
40 #include "Page.h"
41 #include "SVGNames.h"
42 #include "SVGScriptElement.h"
43 #include "ScriptController.h"
44 #include "ScriptRunner.h"
45 #include "ScriptSourceCode.h"
46 #include "ScriptableDocumentParser.h"
47 #include "SecurityOrigin.h"
48 #include "Settings.h"
49 #include "TextNodeTraversal.h"
50 #include <bindings/ScriptValue.h>
51 #include <inspector/ScriptCallStack.h>
52 #include <wtf/StdLibExtras.h>
53 #include <wtf/text/StringBuilder.h>
54 #include <wtf/text/StringHash.h>
55
56 namespace WebCore {
57
58 ScriptElement::ScriptElement(Element& element, bool parserInserted, bool alreadyStarted)
59     : m_element(element)
60     , m_startLineNumber(WTF::OrdinalNumber::beforeFirst())
61     , m_parserInserted(parserInserted)
62     , m_alreadyStarted(alreadyStarted)
63     , m_forceAsync(!parserInserted)
64 {
65     if (parserInserted && m_element.document().scriptableDocumentParser() && !m_element.document().isInDocumentWrite())
66         m_startLineNumber = m_element.document().scriptableDocumentParser()->textPosition().m_line;
67 }
68
69 ScriptElement::~ScriptElement()
70 {
71     stopLoadRequest();
72 }
73
74 bool ScriptElement::shouldCallFinishedInsertingSubtree(ContainerNode& insertionPoint)
75 {
76     return insertionPoint.inDocument() && !m_parserInserted;
77 }
78
79 void ScriptElement::finishedInsertingSubtree()
80 {
81     ASSERT(!m_parserInserted);
82     prepareScript(); // FIXME: Provide a real starting line number here.
83 }
84
85 void ScriptElement::childrenChanged()
86 {
87     if (!m_parserInserted && m_element.inDocument())
88         prepareScript(); // FIXME: Provide a real starting line number here.
89 }
90
91 void ScriptElement::handleSourceAttribute(const String& sourceUrl)
92 {
93     if (ignoresLoadRequest() || sourceUrl.isEmpty())
94         return;
95
96     prepareScript(); // FIXME: Provide a real starting line number here.
97 }
98
99 void ScriptElement::handleAsyncAttribute()
100 {
101     m_forceAsync = false;
102 }
103
104 // Helper function
105 static bool isLegacySupportedJavaScriptLanguage(const String& language)
106 {
107     // Mozilla 1.8 accepts javascript1.0 - javascript1.7, but WinIE 7 accepts only javascript1.1 - javascript1.3.
108     // Mozilla 1.8 and WinIE 7 both accept javascript and livescript.
109     // WinIE 7 accepts ecmascript and jscript, but Mozilla 1.8 doesn't.
110     // Neither Mozilla 1.8 nor WinIE 7 accept leading or trailing whitespace.
111     // We want to accept all the values that either of these browsers accept, but not other values.
112
113     // FIXME: This function is not HTML5 compliant. These belong in the MIME registry as "text/javascript<version>" entries.
114     typedef HashSet<String, CaseFoldingHash> LanguageSet;
115     DEPRECATED_DEFINE_STATIC_LOCAL(LanguageSet, languages, ());
116     if (languages.isEmpty()) {
117         languages.add("javascript");
118         languages.add("javascript");
119         languages.add("javascript1.0");
120         languages.add("javascript1.1");
121         languages.add("javascript1.2");
122         languages.add("javascript1.3");
123         languages.add("javascript1.4");
124         languages.add("javascript1.5");
125         languages.add("javascript1.6");
126         languages.add("javascript1.7");
127         languages.add("livescript");
128         languages.add("ecmascript");
129         languages.add("jscript");
130     }
131
132     return languages.contains(language);
133 }
134
135 void ScriptElement::dispatchErrorEvent()
136 {
137     m_element.dispatchEvent(Event::create(eventNames().errorEvent, false, false));
138 }
139
140 bool ScriptElement::isScriptTypeSupported(LegacyTypeSupport supportLegacyTypes) const
141 {
142     // FIXME: isLegacySupportedJavaScriptLanguage() is not valid HTML5. It is used here to maintain backwards compatibility with existing layout tests. The specific violations are:
143     // - Allowing type=javascript. type= should only support MIME types, such as text/javascript.
144     // - Allowing a different set of languages for language= and type=. language= supports Javascript 1.1 and 1.4-1.6, but type= does not.
145
146     String type = typeAttributeValue();
147     String language = languageAttributeValue();
148     if (type.isEmpty() && language.isEmpty())
149         return true; // Assume text/javascript.
150     if (type.isEmpty()) {
151         type = "text/" + language.lower();
152         if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type) || isLegacySupportedJavaScriptLanguage(language))
153             return true;
154     } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type.stripWhiteSpace().lower()) || (supportLegacyTypes == AllowLegacyTypeInTypeAttribute && isLegacySupportedJavaScriptLanguage(type)))
155         return true;
156     return false;
157 }
158
159 // http://dev.w3.org/html5/spec/Overview.html#prepare-a-script
160 bool ScriptElement::prepareScript(const TextPosition& scriptStartPosition, LegacyTypeSupport supportLegacyTypes)
161 {
162     if (m_alreadyStarted)
163         return false;
164
165     bool wasParserInserted;
166     if (m_parserInserted) {
167         wasParserInserted = true;
168         m_parserInserted = false;
169     } else
170         wasParserInserted = false;
171
172     if (wasParserInserted && !asyncAttributeValue())
173         m_forceAsync = true;
174
175     // FIXME: HTML5 spec says we should check that all children are either comments or empty text nodes.
176     if (!hasSourceAttribute() && !m_element.firstChild())
177         return false;
178
179     if (!m_element.inDocument())
180         return false;
181
182     if (!isScriptTypeSupported(supportLegacyTypes))
183         return false;
184
185     if (wasParserInserted) {
186         m_parserInserted = true;
187         m_forceAsync = false;
188     }
189
190     m_alreadyStarted = true;
191
192     // FIXME: If script is parser inserted, verify it's still in the original document.
193     Document& document = m_element.document();
194
195     // FIXME: Eventually we'd like to evaluate scripts which are inserted into a
196     // viewless document but this'll do for now.
197     // See http://bugs.webkit.org/show_bug.cgi?id=5727
198     if (!document.frame())
199         return false;
200
201     if (!document.frame()->script().canExecuteScripts(AboutToExecuteScript))
202         return false;
203
204     if (!isScriptForEventSupported())
205         return false;
206
207     if (!charsetAttributeValue().isEmpty())
208         m_characterEncoding = charsetAttributeValue();
209     else
210         m_characterEncoding = document.charset();
211
212     if (hasSourceAttribute())
213         if (!requestScript(sourceAttributeValue()))
214             return false;
215
216     if (hasSourceAttribute() && deferAttributeValue() && m_parserInserted && !asyncAttributeValue()) {
217         m_willExecuteWhenDocumentFinishedParsing = true;
218         m_willBeParserExecuted = true;
219     } else if (hasSourceAttribute() && m_parserInserted && !asyncAttributeValue())
220         m_willBeParserExecuted = true;
221     else if (!hasSourceAttribute() && m_parserInserted && !document.haveStylesheetsLoaded()) {
222         m_willBeParserExecuted = true;
223         m_readyToBeParserExecuted = true;
224     } else if (hasSourceAttribute() && !asyncAttributeValue() && !m_forceAsync) {
225         m_willExecuteInOrder = true;
226         document.scriptRunner()->queueScriptForExecution(this, m_cachedScript, ScriptRunner::IN_ORDER_EXECUTION);
227         m_cachedScript->addClient(this);
228     } else if (hasSourceAttribute()) {
229         m_element.document().scriptRunner()->queueScriptForExecution(this, m_cachedScript, ScriptRunner::ASYNC_EXECUTION);
230         m_cachedScript->addClient(this);
231     } else {
232         // Reset line numbering for nested writes.
233         TextPosition position = document.isInDocumentWrite() ? TextPosition() : scriptStartPosition;
234         executeScript(ScriptSourceCode(scriptContent(), document.url(), position));
235     }
236
237     return true;
238 }
239
240 bool ScriptElement::requestScript(const String& sourceUrl)
241 {
242     Ref<Document> originalDocument(m_element.document());
243     if (!m_element.dispatchBeforeLoadEvent(sourceUrl))
244         return false;
245     if (!m_element.inDocument() || &m_element.document() != originalDocument.ptr())
246         return false;
247
248     ASSERT(!m_cachedScript);
249     if (!stripLeadingAndTrailingHTMLSpaces(sourceUrl).isEmpty()) {
250         ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
251         options.setContentSecurityPolicyImposition(m_element.isInUserAgentShadowTree() ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck);
252
253         CachedResourceRequest request(ResourceRequest(m_element.document().completeURL(sourceUrl)), options);
254
255         String crossOriginMode = m_element.fastGetAttribute(HTMLNames::crossoriginAttr);
256         if (!crossOriginMode.isNull()) {
257             m_requestUsesAccessControl = true;
258             StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
259             updateRequestForAccessControl(request.mutableResourceRequest(), m_element.document().securityOrigin(), allowCredentials);
260         }
261         request.setCharset(scriptCharset());
262         request.setInitiator(&element());
263
264         m_cachedScript = m_element.document().cachedResourceLoader().requestScript(request);
265         m_isExternalScript = true;
266     }
267
268     if (m_cachedScript) {
269         return true;
270     }
271
272     dispatchErrorEvent();
273     return false;
274 }
275
276 void ScriptElement::executeScript(const ScriptSourceCode& sourceCode)
277 {
278     ASSERT(m_alreadyStarted);
279
280     if (sourceCode.isEmpty())
281         return;
282
283     if (!m_isExternalScript && !m_element.document().contentSecurityPolicy()->allowInlineScript(m_element.document().url(), m_startLineNumber, m_element.isInUserAgentShadowTree()))
284         return;
285
286 #if ENABLE(NOSNIFF)
287     if (m_isExternalScript && m_cachedScript && !m_cachedScript->mimeTypeAllowedByNosniff()) {
288         m_element.document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, "Refused to execute script from '" + m_cachedScript->url().stringCenterEllipsizedToLength() + "' because its MIME type ('" + m_cachedScript->mimeType() + "') is not executable, and strict MIME type checking is enabled.");
289         return;
290     }
291 #endif
292
293     Ref<Document> document(m_element.document());
294     if (Frame* frame = document->frame()) {
295         IgnoreDestructiveWriteCountIncrementer ignoreDesctructiveWriteCountIncrementer(m_isExternalScript ? document.ptr() : nullptr);
296         CurrentScriptIncrementer currentScriptIncrementer(document, &m_element);
297
298         // Create a script from the script element node, using the script
299         // block's source and the script block's type.
300         // Note: This is where the script is compiled and actually executed.
301         frame->script().evaluate(sourceCode);
302     }
303 }
304
305 void ScriptElement::stopLoadRequest()
306 {
307     if (m_cachedScript) {
308         if (!m_willBeParserExecuted)
309             m_cachedScript->removeClient(this);
310         m_cachedScript = nullptr;
311     }
312 }
313
314 void ScriptElement::execute(CachedScript* cachedScript)
315 {
316     ASSERT(!m_willBeParserExecuted);
317     ASSERT(cachedScript);
318     if (cachedScript->errorOccurred())
319         dispatchErrorEvent();
320     else if (!cachedScript->wasCanceled()) {
321         executeScript(ScriptSourceCode(cachedScript));
322         dispatchLoadEvent();
323     }
324     cachedScript->removeClient(this);
325 }
326
327 void ScriptElement::notifyFinished(CachedResource* resource)
328 {
329     ASSERT(!m_willBeParserExecuted);
330
331     // CachedResource possibly invokes this notifyFinished() more than
332     // once because ScriptElement doesn't unsubscribe itself from
333     // CachedResource here and does it in execute() instead.
334     // We use m_cachedScript to check if this function is already called.
335     ASSERT_UNUSED(resource, resource == m_cachedScript);
336     if (!m_cachedScript)
337         return;
338
339     if (m_requestUsesAccessControl && !m_cachedScript->passesSameOriginPolicyCheck(*m_element.document().securityOrigin())) {
340         dispatchErrorEvent();
341         DEPRECATED_DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Cross-origin script load denied by Cross-Origin Resource Sharing policy.")));
342         m_element.document().addConsoleMessage(MessageSource::JS, MessageLevel::Error, consoleMessage);
343         return;
344     }
345
346     if (m_willExecuteInOrder)
347         m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::IN_ORDER_EXECUTION);
348     else
349         m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::ASYNC_EXECUTION);
350
351     m_cachedScript = nullptr;
352 }
353
354 bool ScriptElement::ignoresLoadRequest() const
355 {
356     return m_alreadyStarted || m_isExternalScript || m_parserInserted || !m_element.inDocument();
357 }
358
359 bool ScriptElement::isScriptForEventSupported() const
360 {
361     String eventAttribute = eventAttributeValue();
362     String forAttribute = forAttributeValue();
363     if (!eventAttribute.isNull() && !forAttribute.isNull()) {
364         forAttribute = stripLeadingAndTrailingHTMLSpaces(forAttribute);
365         if (!equalIgnoringCase(forAttribute, "window"))
366             return false;
367
368         eventAttribute = stripLeadingAndTrailingHTMLSpaces(eventAttribute);
369         if (!equalIgnoringCase(eventAttribute, "onload") && !equalIgnoringCase(eventAttribute, "onload()"))
370             return false;
371     }
372     return true;
373 }
374
375 String ScriptElement::scriptContent() const
376 {
377     StringBuilder result;
378     for (auto* text = TextNodeTraversal::firstChild(m_element); text; text = TextNodeTraversal::nextSibling(*text))
379         result.append(text->data());
380     return result.toString();
381 }
382
383 ScriptElement* toScriptElementIfPossible(Element* element)
384 {
385     if (is<HTMLScriptElement>(*element))
386         return downcast<HTMLScriptElement>(element);
387
388     if (is<SVGScriptElement>(*element))
389         return downcast<SVGScriptElement>(element);
390
391     return nullptr;
392 }
393
394 }