f71f67a9efe0f0c462c84876793f6f9acc058988
[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_cachedScript(0)
61     , m_startLineNumber(WTF::OrdinalNumber::beforeFirst())
62     , m_parserInserted(parserInserted)
63     , m_isExternalScript(false)
64     , m_alreadyStarted(alreadyStarted)
65     , m_haveFiredLoad(false)
66     , m_willBeParserExecuted(false)
67     , m_readyToBeParserExecuted(false)
68     , m_willExecuteWhenDocumentFinishedParsing(false)
69     , m_forceAsync(!parserInserted)
70     , m_willExecuteInOrder(false)
71     , m_requestUsesAccessControl(false)
72 {
73     if (parserInserted && m_element.document().scriptableDocumentParser() && !m_element.document().isInDocumentWrite())
74         m_startLineNumber = m_element.document().scriptableDocumentParser()->textPosition().m_line;
75 }
76
77 ScriptElement::~ScriptElement()
78 {
79     stopLoadRequest();
80 }
81
82 bool ScriptElement::shouldCallFinishedInsertingSubtree(ContainerNode& insertionPoint)
83 {
84     return insertionPoint.inDocument() && !m_parserInserted;
85 }
86
87 void ScriptElement::finishedInsertingSubtree()
88 {
89     ASSERT(!m_parserInserted);
90     prepareScript(); // FIXME: Provide a real starting line number here.
91 }
92
93 void ScriptElement::childrenChanged()
94 {
95     if (!m_parserInserted && m_element.inDocument())
96         prepareScript(); // FIXME: Provide a real starting line number here.
97 }
98
99 void ScriptElement::handleSourceAttribute(const String& sourceUrl)
100 {
101     if (ignoresLoadRequest() || sourceUrl.isEmpty())
102         return;
103
104     prepareScript(); // FIXME: Provide a real starting line number here.
105 }
106
107 void ScriptElement::handleAsyncAttribute()
108 {
109     m_forceAsync = false;
110 }
111
112 // Helper function
113 static bool isLegacySupportedJavaScriptLanguage(const String& language)
114 {
115     // Mozilla 1.8 accepts javascript1.0 - javascript1.7, but WinIE 7 accepts only javascript1.1 - javascript1.3.
116     // Mozilla 1.8 and WinIE 7 both accept javascript and livescript.
117     // WinIE 7 accepts ecmascript and jscript, but Mozilla 1.8 doesn't.
118     // Neither Mozilla 1.8 nor WinIE 7 accept leading or trailing whitespace.
119     // We want to accept all the values that either of these browsers accept, but not other values.
120
121     // FIXME: This function is not HTML5 compliant. These belong in the MIME registry as "text/javascript<version>" entries.
122     typedef HashSet<String, CaseFoldingHash> LanguageSet;
123     DEPRECATED_DEFINE_STATIC_LOCAL(LanguageSet, languages, ());
124     if (languages.isEmpty()) {
125         languages.add("javascript");
126         languages.add("javascript");
127         languages.add("javascript1.0");
128         languages.add("javascript1.1");
129         languages.add("javascript1.2");
130         languages.add("javascript1.3");
131         languages.add("javascript1.4");
132         languages.add("javascript1.5");
133         languages.add("javascript1.6");
134         languages.add("javascript1.7");
135         languages.add("livescript");
136         languages.add("ecmascript");
137         languages.add("jscript");
138     }
139
140     return languages.contains(language);
141 }
142
143 void ScriptElement::dispatchErrorEvent()
144 {
145     m_element.dispatchEvent(Event::create(eventNames().errorEvent, false, false));
146 }
147
148 bool ScriptElement::isScriptTypeSupported(LegacyTypeSupport supportLegacyTypes) const
149 {
150     // FIXME: isLegacySupportedJavaScriptLanguage() is not valid HTML5. It is used here to maintain backwards compatibility with existing layout tests. The specific violations are:
151     // - Allowing type=javascript. type= should only support MIME types, such as text/javascript.
152     // - Allowing a different set of languages for language= and type=. language= supports Javascript 1.1 and 1.4-1.6, but type= does not.
153
154     String type = typeAttributeValue();
155     String language = languageAttributeValue();
156     if (type.isEmpty() && language.isEmpty())
157         return true; // Assume text/javascript.
158     if (type.isEmpty()) {
159         type = "text/" + language.lower();
160         if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type) || isLegacySupportedJavaScriptLanguage(language))
161             return true;
162     } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type.stripWhiteSpace().lower()) || (supportLegacyTypes == AllowLegacyTypeInTypeAttribute && isLegacySupportedJavaScriptLanguage(type)))
163         return true;
164     return false;
165 }
166
167 // http://dev.w3.org/html5/spec/Overview.html#prepare-a-script
168 bool ScriptElement::prepareScript(const TextPosition& scriptStartPosition, LegacyTypeSupport supportLegacyTypes)
169 {
170     if (m_alreadyStarted)
171         return false;
172
173     bool wasParserInserted;
174     if (m_parserInserted) {
175         wasParserInserted = true;
176         m_parserInserted = false;
177     } else
178         wasParserInserted = false;
179
180     if (wasParserInserted && !asyncAttributeValue())
181         m_forceAsync = true;
182
183     // FIXME: HTML5 spec says we should check that all children are either comments or empty text nodes.
184     if (!hasSourceAttribute() && !m_element.firstChild())
185         return false;
186
187     if (!m_element.inDocument())
188         return false;
189
190     if (!isScriptTypeSupported(supportLegacyTypes))
191         return false;
192
193     if (wasParserInserted) {
194         m_parserInserted = true;
195         m_forceAsync = false;
196     }
197
198     m_alreadyStarted = true;
199
200     // FIXME: If script is parser inserted, verify it's still in the original document.
201     Document& document = m_element.document();
202
203     // FIXME: Eventually we'd like to evaluate scripts which are inserted into a
204     // viewless document but this'll do for now.
205     // See http://bugs.webkit.org/show_bug.cgi?id=5727
206     if (!document.frame())
207         return false;
208
209     if (!document.frame()->script().canExecuteScripts(AboutToExecuteScript))
210         return false;
211
212     if (!isScriptForEventSupported())
213         return false;
214
215     if (!charsetAttributeValue().isEmpty())
216         m_characterEncoding = charsetAttributeValue();
217     else
218         m_characterEncoding = document.charset();
219
220     if (hasSourceAttribute())
221         if (!requestScript(sourceAttributeValue()))
222             return false;
223
224     if (hasSourceAttribute() && deferAttributeValue() && m_parserInserted && !asyncAttributeValue()) {
225         m_willExecuteWhenDocumentFinishedParsing = true;
226         m_willBeParserExecuted = true;
227     } else if (hasSourceAttribute() && m_parserInserted && !asyncAttributeValue())
228         m_willBeParserExecuted = true;
229     else if (!hasSourceAttribute() && m_parserInserted && !document.haveStylesheetsLoaded()) {
230         m_willBeParserExecuted = true;
231         m_readyToBeParserExecuted = true;
232     } else if (hasSourceAttribute() && !asyncAttributeValue() && !m_forceAsync) {
233         m_willExecuteInOrder = true;
234         document.scriptRunner()->queueScriptForExecution(this, m_cachedScript, ScriptRunner::IN_ORDER_EXECUTION);
235         m_cachedScript->addClient(this);
236     } else if (hasSourceAttribute()) {
237         m_element.document().scriptRunner()->queueScriptForExecution(this, m_cachedScript, ScriptRunner::ASYNC_EXECUTION);
238         m_cachedScript->addClient(this);
239     } else {
240         // Reset line numbering for nested writes.
241         TextPosition position = document.isInDocumentWrite() ? TextPosition() : scriptStartPosition;
242         executeScript(ScriptSourceCode(scriptContent(), document.url(), position));
243     }
244
245     return true;
246 }
247
248 bool ScriptElement::requestScript(const String& sourceUrl)
249 {
250     Ref<Document> originalDocument(m_element.document());
251     if (!m_element.dispatchBeforeLoadEvent(sourceUrl))
252         return false;
253     if (!m_element.inDocument() || &m_element.document() != originalDocument.ptr())
254         return false;
255
256     ASSERT(!m_cachedScript);
257     if (!stripLeadingAndTrailingHTMLSpaces(sourceUrl).isEmpty()) {
258         ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
259         options.setContentSecurityPolicyImposition(m_element.isInUserAgentShadowTree() ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck);
260
261         CachedResourceRequest request(ResourceRequest(m_element.document().completeURL(sourceUrl)), options);
262
263         String crossOriginMode = m_element.fastGetAttribute(HTMLNames::crossoriginAttr);
264         if (!crossOriginMode.isNull()) {
265             m_requestUsesAccessControl = true;
266             StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
267             updateRequestForAccessControl(request.mutableResourceRequest(), m_element.document().securityOrigin(), allowCredentials);
268         }
269         request.setCharset(scriptCharset());
270         request.setInitiator(&element());
271
272         m_cachedScript = m_element.document().cachedResourceLoader().requestScript(request);
273         m_isExternalScript = true;
274     }
275
276     if (m_cachedScript) {
277         return true;
278     }
279
280     dispatchErrorEvent();
281     return false;
282 }
283
284 void ScriptElement::executeScript(const ScriptSourceCode& sourceCode)
285 {
286     ASSERT(m_alreadyStarted);
287
288     if (sourceCode.isEmpty())
289         return;
290
291     if (!m_isExternalScript && !m_element.document().contentSecurityPolicy()->allowInlineScript(m_element.document().url(), m_startLineNumber, m_element.isInUserAgentShadowTree()))
292         return;
293
294 #if ENABLE(NOSNIFF)
295     if (m_isExternalScript && m_cachedScript && !m_cachedScript->mimeTypeAllowedByNosniff()) {
296         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.");
297         return;
298     }
299 #endif
300
301     Ref<Document> document(m_element.document());
302     if (Frame* frame = document->frame()) {
303         IgnoreDestructiveWriteCountIncrementer ignoreDesctructiveWriteCountIncrementer(m_isExternalScript ? document.ptr() : nullptr);
304         CurrentScriptIncrementer currentScriptIncrementer(document, &m_element);
305
306         // Create a script from the script element node, using the script
307         // block's source and the script block's type.
308         // Note: This is where the script is compiled and actually executed.
309         frame->script().evaluate(sourceCode);
310     }
311 }
312
313 void ScriptElement::stopLoadRequest()
314 {
315     if (m_cachedScript) {
316         if (!m_willBeParserExecuted)
317             m_cachedScript->removeClient(this);
318         m_cachedScript = 0;
319     }
320 }
321
322 void ScriptElement::execute(CachedScript* cachedScript)
323 {
324     ASSERT(!m_willBeParserExecuted);
325     ASSERT(cachedScript);
326     if (cachedScript->errorOccurred())
327         dispatchErrorEvent();
328     else if (!cachedScript->wasCanceled()) {
329         executeScript(ScriptSourceCode(cachedScript));
330         dispatchLoadEvent();
331     }
332     cachedScript->removeClient(this);
333 }
334
335 void ScriptElement::notifyFinished(CachedResource* resource)
336 {
337     ASSERT(!m_willBeParserExecuted);
338
339     // CachedResource possibly invokes this notifyFinished() more than
340     // once because ScriptElement doesn't unsubscribe itself from
341     // CachedResource here and does it in execute() instead.
342     // We use m_cachedScript to check if this function is already called.
343     ASSERT_UNUSED(resource, resource == m_cachedScript);
344     if (!m_cachedScript)
345         return;
346
347     if (m_requestUsesAccessControl && !m_cachedScript->passesSameOriginPolicyCheck(*m_element.document().securityOrigin())) {
348         dispatchErrorEvent();
349         DEPRECATED_DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Cross-origin script load denied by Cross-Origin Resource Sharing policy.")));
350         m_element.document().addConsoleMessage(MessageSource::JS, MessageLevel::Error, consoleMessage);
351         return;
352     }
353
354     if (m_willExecuteInOrder)
355         m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::IN_ORDER_EXECUTION);
356     else
357         m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::ASYNC_EXECUTION);
358
359     m_cachedScript = 0;
360 }
361
362 bool ScriptElement::ignoresLoadRequest() const
363 {
364     return m_alreadyStarted || m_isExternalScript || m_parserInserted || !m_element.inDocument();
365 }
366
367 bool ScriptElement::isScriptForEventSupported() const
368 {
369     String eventAttribute = eventAttributeValue();
370     String forAttribute = forAttributeValue();
371     if (!eventAttribute.isNull() && !forAttribute.isNull()) {
372         forAttribute = stripLeadingAndTrailingHTMLSpaces(forAttribute);
373         if (!equalIgnoringCase(forAttribute, "window"))
374             return false;
375
376         eventAttribute = stripLeadingAndTrailingHTMLSpaces(eventAttribute);
377         if (!equalIgnoringCase(eventAttribute, "onload") && !equalIgnoringCase(eventAttribute, "onload()"))
378             return false;
379     }
380     return true;
381 }
382
383 String ScriptElement::scriptContent() const
384 {
385     StringBuilder result;
386     for (auto* text = TextNodeTraversal::firstChild(m_element); text; text = TextNodeTraversal::nextSibling(*text))
387         result.append(text->data());
388     return result.toString();
389 }
390
391 ScriptElement* toScriptElementIfPossible(Element* element)
392 {
393     if (is<HTMLScriptElement>(*element))
394         return downcast<HTMLScriptElement>(element);
395
396     if (is<SVGScriptElement>(*element))
397         return downcast<SVGScriptElement>(element);
398
399     return nullptr;
400 }
401
402 }