The Tor Browser / file comparison

comparison: content/base/src/nsScriptLoader.cpp

content/base/src/nsScriptLoader.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:42c510ae3037
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 // vim: ft=cpp tw=78 sw=2 et ts=2
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 /*
8 * A class that handles loading and evaluation of <script> elements.
9 */
10
11 #include "nsScriptLoader.h"
12
13 #include "jsapi.h"
14 #include "jsfriendapi.h"
15 #include "nsIUnicodeDecoder.h"
16 #include "nsIContent.h"
17 #include "nsJSUtils.h"
18 #include "mozilla/dom/ScriptSettings.h"
19 #include "mozilla/dom/Element.h"
20 #include "nsGkAtoms.h"
21 #include "nsNetUtil.h"
22 #include "nsIJSRuntimeService.h"
23 #include "nsIScriptGlobalObject.h"
24 #include "nsIScriptContext.h"
25 #include "nsIScriptSecurityManager.h"
26 #include "nsIPrincipal.h"
27 #include "nsJSPrincipals.h"
28 #include "nsContentPolicyUtils.h"
29 #include "nsIHttpChannel.h"
30 #include "nsIHttpChannelInternal.h"
31 #include "nsITimedChannel.h"
32 #include "nsIScriptElement.h"
33 #include "nsIDOMHTMLScriptElement.h"
34 #include "nsIDocShell.h"
35 #include "nsContentUtils.h"
36 #include "nsCxPusher.h"
37 #include "nsUnicharUtils.h"
38 #include "nsAutoPtr.h"
39 #include "nsIXPConnect.h"
40 #include "nsError.h"
41 #include "nsThreadUtils.h"
42 #include "nsDocShellCID.h"
43 #include "nsIContentSecurityPolicy.h"
44 #include "prlog.h"
45 #include "nsIChannelPolicy.h"
46 #include "nsChannelPolicy.h"
47 #include "nsCRT.h"
48 #include "nsContentCreatorFunctions.h"
49 #include "nsCrossSiteListenerProxy.h"
50 #include "nsSandboxFlags.h"
51 #include "nsContentTypeParser.h"
52 #include "nsINetworkSeer.h"
53 #include "mozilla/dom/EncodingUtils.h"
54
55 #include "mozilla/CORSMode.h"
56 #include "mozilla/Attributes.h"
57 #include "mozilla/unused.h"
58
59 #ifdef PR_LOGGING
60 static PRLogModuleInfo* gCspPRLog;
61 #endif
62
63 using namespace mozilla;
64 using namespace mozilla::dom;
65
66 //////////////////////////////////////////////////////////////
67 // Per-request data structure
68 //////////////////////////////////////////////////////////////
69
70 class nsScriptLoadRequest MOZ_FINAL : public nsISupports {
71 public:
72 nsScriptLoadRequest(nsIScriptElement* aElement,
73 uint32_t aVersion,
74 CORSMode aCORSMode)
75 : mElement(aElement),
76 mLoading(true),
77 mIsInline(true),
78 mHasSourceMapURL(false),
79 mScriptTextBuf(nullptr),
80 mScriptTextLength(0),
81 mJSVersion(aVersion),
82 mLineNo(1),
83 mCORSMode(aCORSMode)
84 {
85 }
86
87 ~nsScriptLoadRequest()
88 {
89 if (mScriptTextBuf) {
90 js_free(mScriptTextBuf);
91 }
92 }
93
94 NS_DECL_THREADSAFE_ISUPPORTS
95
96 void FireScriptAvailable(nsresult aResult)
97 {
98 mElement->ScriptAvailable(aResult, mElement, mIsInline, mURI, mLineNo);
99 }
100 void FireScriptEvaluated(nsresult aResult)
101 {
102 mElement->ScriptEvaluated(aResult, mElement, mIsInline);
103 }
104
105 bool IsPreload()
106 {
107 return mElement == nullptr;
108 }
109
110 nsCOMPtr<nsIScriptElement> mElement;
111 bool mLoading; // Are we still waiting for a load to complete?
112 bool mIsInline; // Is the script inline or loaded?
113 bool mHasSourceMapURL; // Does the HTTP header have a source map url?
114 nsString mSourceMapURL; // Holds source map url for loaded scripts
115 jschar* mScriptTextBuf; // Holds script text for non-inline scripts. Don't
116 size_t mScriptTextLength; // use nsString so we can give ownership to jsapi.
117 uint32_t mJSVersion;
118 nsCOMPtr<nsIURI> mURI;
119 nsCOMPtr<nsIPrincipal> mOriginPrincipal;
120 nsAutoCString mURL; // Keep the URI's filename alive during off thread parsing.
121 int32_t mLineNo;
122 const CORSMode mCORSMode;
123 };
124
125 // The nsScriptLoadRequest is passed as the context to necko, and thus
126 // it needs to be threadsafe. Necko won't do anything with this
127 // context, but it will AddRef and Release it on other threads.
128 NS_IMPL_ISUPPORTS0(nsScriptLoadRequest)
129
130 //////////////////////////////////////////////////////////////
131 //
132 //////////////////////////////////////////////////////////////
133
134 nsScriptLoader::nsScriptLoader(nsIDocument *aDocument)
135 : mDocument(aDocument),
136 mBlockerCount(0),
137 mEnabled(true),
138 mDeferEnabled(false),
139 mDocumentParsingDone(false),
140 mBlockingDOMContentLoaded(false)
141 {
142 // enable logging for CSP
143 #ifdef PR_LOGGING
144 if (!gCspPRLog)
145 gCspPRLog = PR_NewLogModule("CSP");
146 #endif
147 }
148
149 nsScriptLoader::~nsScriptLoader()
150 {
151 mObservers.Clear();
152
153 if (mParserBlockingRequest) {
154 mParserBlockingRequest->FireScriptAvailable(NS_ERROR_ABORT);
155 }
156
157 for (uint32_t i = 0; i < mXSLTRequests.Length(); i++) {
158 mXSLTRequests[i]->FireScriptAvailable(NS_ERROR_ABORT);
159 }
160
161 for (uint32_t i = 0; i < mDeferRequests.Length(); i++) {
162 mDeferRequests[i]->FireScriptAvailable(NS_ERROR_ABORT);
163 }
164
165 for (uint32_t i = 0; i < mAsyncRequests.Length(); i++) {
166 mAsyncRequests[i]->FireScriptAvailable(NS_ERROR_ABORT);
167 }
168
169 for (uint32_t i = 0; i < mNonAsyncExternalScriptInsertedRequests.Length(); i++) {
170 mNonAsyncExternalScriptInsertedRequests[i]->FireScriptAvailable(NS_ERROR_ABORT);
171 }
172
173 // Unblock the kids, in case any of them moved to a different document
174 // subtree in the meantime and therefore aren't actually going away.
175 for (uint32_t j = 0; j < mPendingChildLoaders.Length(); ++j) {
176 mPendingChildLoaders[j]->RemoveExecuteBlocker();
177 }
178 }
179
180 NS_IMPL_ISUPPORTS(nsScriptLoader, nsIStreamLoaderObserver)
181
182 // Helper method for checking if the script element is an event-handler
183 // This means that it has both a for-attribute and a event-attribute.
184 // Also, if the for-attribute has a value that matches "\s*window\s*",
185 // and the event-attribute matches "\s*onload([ \(].*)?" then it isn't an
186 // eventhandler. (both matches are case insensitive).
187 // This is how IE seems to filter out a window's onload handler from a
188 // <script for=... event=...> element.
189
190 static bool
191 IsScriptEventHandler(nsIContent* aScriptElement)
192 {
193 if (!aScriptElement->IsHTML()) {
194 return false;
195 }
196
197 nsAutoString forAttr, eventAttr;
198 if (!aScriptElement->GetAttr(kNameSpaceID_None, nsGkAtoms::_for, forAttr) ||
199 !aScriptElement->GetAttr(kNameSpaceID_None, nsGkAtoms::event, eventAttr)) {
200 return false;
201 }
202
203 const nsAString& for_str =
204 nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(forAttr);
205 if (!for_str.LowerCaseEqualsLiteral("window")) {
206 return true;
207 }
208
209 // We found for="window", now check for event="onload".
210 const nsAString& event_str =
211 nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(eventAttr, false);
212 if (!StringBeginsWith(event_str, NS_LITERAL_STRING("onload"),
213 nsCaseInsensitiveStringComparator())) {
214 // It ain't "onload.*".
215
216 return true;
217 }
218
219 nsAutoString::const_iterator start, end;
220 event_str.BeginReading(start);
221 event_str.EndReading(end);
222
223 start.advance(6); // advance past "onload"
224
225 if (start != end && *start != '(' && *start != ' ') {
226 // We got onload followed by something other than space or
227 // '('. Not good enough.
228
229 return true;
230 }
231
232 return false;
233 }
234
235 nsresult
236 nsScriptLoader::CheckContentPolicy(nsIDocument* aDocument,
237 nsISupports *aContext,
238 nsIURI *aURI,
239 const nsAString &aType)
240 {
241 int16_t shouldLoad = nsIContentPolicy::ACCEPT;
242 nsresult rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_SCRIPT,
243 aURI,
244 aDocument->NodePrincipal(),
245 aContext,
246 NS_LossyConvertUTF16toASCII(aType),
247 nullptr, //extra
248 &shouldLoad,
249 nsContentUtils::GetContentPolicy(),
250 nsContentUtils::GetSecurityManager());
251 if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
252 if (NS_FAILED(rv) || shouldLoad != nsIContentPolicy::REJECT_TYPE) {
253 return NS_ERROR_CONTENT_BLOCKED;
254 }
255 return NS_ERROR_CONTENT_BLOCKED_SHOW_ALT;
256 }
257
258 return NS_OK;
259 }
260
261 nsresult
262 nsScriptLoader::ShouldLoadScript(nsIDocument* aDocument,
263 nsISupports* aContext,
264 nsIURI* aURI,
265 const nsAString &aType)
266 {
267 // Check that the containing page is allowed to load this URI.
268 nsresult rv = nsContentUtils::GetSecurityManager()->
269 CheckLoadURIWithPrincipal(aDocument->NodePrincipal(), aURI,
270 nsIScriptSecurityManager::ALLOW_CHROME);
271
272 NS_ENSURE_SUCCESS(rv, rv);
273
274 // After the security manager, the content-policy stuff gets a veto
275 rv = CheckContentPolicy(aDocument, aContext, aURI, aType);
276 if (NS_FAILED(rv)) {
277 return rv;
278 }
279
280 return NS_OK;
281 }
282
283 nsresult
284 nsScriptLoader::StartLoad(nsScriptLoadRequest *aRequest, const nsAString &aType,
285 bool aScriptFromHead)
286 {
287 nsISupports *context = aRequest->mElement.get()
288 ? static_cast<nsISupports *>(aRequest->mElement.get())
289 : static_cast<nsISupports *>(mDocument);
290 nsresult rv = ShouldLoadScript(mDocument, context, aRequest->mURI, aType);
291 if (NS_FAILED(rv)) {
292 return rv;
293 }
294
295 nsCOMPtr<nsILoadGroup> loadGroup = mDocument->GetDocumentLoadGroup();
296
297 nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(mDocument->GetWindow()));
298 if (!window) {
299 return NS_ERROR_NULL_POINTER;
300 }
301
302 nsIDocShell *docshell = window->GetDocShell();
303
304 nsCOMPtr<nsIInterfaceRequestor> prompter(do_QueryInterface(docshell));
305
306 // If this document is sandboxed without 'allow-scripts', abort.
307 if (mDocument->GetSandboxFlags() & SANDBOXED_SCRIPTS) {
308 return NS_OK;
309 }
310
311 // check for a Content Security Policy to pass down to the channel
312 // that will be created to load the script
313 nsCOMPtr<nsIChannelPolicy> channelPolicy;
314 nsCOMPtr<nsIContentSecurityPolicy> csp;
315 rv = mDocument->NodePrincipal()->GetCsp(getter_AddRefs(csp));
316 NS_ENSURE_SUCCESS(rv, rv);
317 if (csp) {
318 channelPolicy = do_CreateInstance("@mozilla.org/nschannelpolicy;1");
319 channelPolicy->SetContentSecurityPolicy(csp);
320 channelPolicy->SetLoadType(nsIContentPolicy::TYPE_SCRIPT);
321 }
322
323 nsCOMPtr<nsIChannel> channel;
324 rv = NS_NewChannel(getter_AddRefs(channel),
325 aRequest->mURI, nullptr, loadGroup, prompter,
326 nsIRequest::LOAD_NORMAL | nsIChannel::LOAD_CLASSIFY_URI,
327 channelPolicy);
328 NS_ENSURE_SUCCESS(rv, rv);
329
330 nsIScriptElement *script = aRequest->mElement;
331 if (aScriptFromHead &&
332 !(script && (script->GetScriptAsync() || script->GetScriptDeferred()))) {
333 nsCOMPtr<nsIHttpChannelInternal>
334 internalHttpChannel(do_QueryInterface(channel));
335 if (internalHttpChannel)
336 internalHttpChannel->SetLoadAsBlocking(true);
337 }
338
339 nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
340 if (httpChannel) {
341 // HTTP content negotation has little value in this context.
342 httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept"),
343 NS_LITERAL_CSTRING("*/*"),
344 false);
345 httpChannel->SetReferrer(mDocument->GetDocumentURI());
346 }
347
348 nsCOMPtr<nsILoadContext> loadContext(do_QueryInterface(docshell));
349 mozilla::net::SeerLearn(aRequest->mURI, mDocument->GetDocumentURI(),
350 nsINetworkSeer::LEARN_LOAD_SUBRESOURCE, loadContext);
351
352 // Set the initiator type
353 nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(httpChannel));
354 if (timedChannel) {
355 timedChannel->SetInitiatorType(NS_LITERAL_STRING("script"));
356 }
357
358 nsCOMPtr<nsIStreamLoader> loader;
359 rv = NS_NewStreamLoader(getter_AddRefs(loader), this);
360 NS_ENSURE_SUCCESS(rv, rv);
361
362 nsCOMPtr<nsIStreamListener> listener = loader.get();
363
364 if (aRequest->mCORSMode != CORS_NONE) {
365 bool withCredentials = (aRequest->mCORSMode == CORS_USE_CREDENTIALS);
366 nsRefPtr<nsCORSListenerProxy> corsListener =
367 new nsCORSListenerProxy(listener, mDocument->NodePrincipal(),
368 withCredentials);
369 rv = corsListener->Init(channel);
370 NS_ENSURE_SUCCESS(rv, rv);
371 listener = corsListener;
372 }
373
374 rv = channel->AsyncOpen(listener, aRequest);
375 NS_ENSURE_SUCCESS(rv, rv);
376
377 return NS_OK;
378 }
379
380 bool
381 nsScriptLoader::PreloadURIComparator::Equals(const PreloadInfo &aPi,
382 nsIURI * const &aURI) const
383 {
384 bool same;
385 return NS_SUCCEEDED(aPi.mRequest->mURI->Equals(aURI, &same)) &&
386 same;
387 }
388
389 class nsScriptRequestProcessor : public nsRunnable
390 {
391 private:
392 nsRefPtr<nsScriptLoader> mLoader;
393 nsRefPtr<nsScriptLoadRequest> mRequest;
394 public:
395 nsScriptRequestProcessor(nsScriptLoader* aLoader,
396 nsScriptLoadRequest* aRequest)
397 : mLoader(aLoader)
398 , mRequest(aRequest)
399 {}
400 NS_IMETHODIMP Run()
401 {
402 return mLoader->ProcessRequest(mRequest);
403 }
404 };
405
406 static inline bool
407 ParseTypeAttribute(const nsAString& aType, JSVersion* aVersion)
408 {
409 MOZ_ASSERT(!aType.IsEmpty());
410 MOZ_ASSERT(aVersion);
411 MOZ_ASSERT(*aVersion == JSVERSION_DEFAULT);
412
413 nsContentTypeParser parser(aType);
414
415 nsAutoString mimeType;
416 nsresult rv = parser.GetType(mimeType);
417 NS_ENSURE_SUCCESS(rv, false);
418
419 if (!nsContentUtils::IsJavascriptMIMEType(mimeType)) {
420 return false;
421 }
422
423 // Get the version string, and ensure the language supports it.
424 nsAutoString versionName;
425 rv = parser.GetParameter("version", versionName);
426
427 if (NS_SUCCEEDED(rv)) {
428 *aVersion = nsContentUtils::ParseJavascriptVersion(versionName);
429 } else if (rv != NS_ERROR_INVALID_ARG) {
430 return false;
431 }
432
433 return true;
434 }
435
436 bool
437 CSPAllowsInlineScript(nsIScriptElement *aElement, nsIDocument *aDocument)
438 {
439 nsCOMPtr<nsIContentSecurityPolicy> csp;
440 nsresult rv = aDocument->NodePrincipal()->GetCsp(getter_AddRefs(csp));
441 NS_ENSURE_SUCCESS(rv, false);
442
443 if (!csp) {
444 // no CSP --> allow
445 return true;
446 }
447
448 // An inline script can be allowed because all inline scripts are allowed,
449 // or else because it is whitelisted by a nonce-source or hash-source. This
450 // is a logical OR between whitelisting methods, so the allowInlineScript
451 // outparam can be reused for each check as long as we stop checking as soon
452 // as it is set to true. This also optimizes performance by avoiding the
453 // overhead of unnecessary checks.
454 bool allowInlineScript = true;
455 nsAutoTArray<unsigned short, 3> violations;
456
457 bool reportInlineViolation = false;
458 rv = csp->GetAllowsInlineScript(&reportInlineViolation, &allowInlineScript);
459 NS_ENSURE_SUCCESS(rv, false);
460 if (reportInlineViolation) {
461 violations.AppendElement(static_cast<unsigned short>(
462 nsIContentSecurityPolicy::VIOLATION_TYPE_INLINE_SCRIPT));
463 }
464
465 nsAutoString nonce;
466 if (!allowInlineScript) {
467 nsCOMPtr<nsIContent> scriptContent = do_QueryInterface(aElement);
468 bool foundNonce = scriptContent->GetAttr(kNameSpaceID_None,
469 nsGkAtoms::nonce, nonce);
470 if (foundNonce) {
471 bool reportNonceViolation;
472 rv = csp->GetAllowsNonce(nonce, nsIContentPolicy::TYPE_SCRIPT,
473 &reportNonceViolation, &allowInlineScript);
474 NS_ENSURE_SUCCESS(rv, false);
475 if (reportNonceViolation) {
476 violations.AppendElement(static_cast<unsigned short>(
477 nsIContentSecurityPolicy::VIOLATION_TYPE_NONCE_SCRIPT));
478 }
479 }
480 }
481
482 if (!allowInlineScript) {
483 bool reportHashViolation;
484 nsAutoString scriptText;
485 aElement->GetScriptText(scriptText);
486 rv = csp->GetAllowsHash(scriptText, nsIContentPolicy::TYPE_SCRIPT,
487 &reportHashViolation, &allowInlineScript);
488 NS_ENSURE_SUCCESS(rv, false);
489 if (reportHashViolation) {
490 violations.AppendElement(static_cast<unsigned short>(
491 nsIContentSecurityPolicy::VIOLATION_TYPE_HASH_SCRIPT));
492 }
493 }
494
495 // What violation(s) should be reported?
496 //
497 // 1. If the script tag has a nonce attribute, and the nonce does not match
498 // the policy, report VIOLATION_TYPE_NONCE_SCRIPT.
499 // 2. If the policy has at least one hash-source, and the hashed contents of
500 // the script tag did not match any of them, report VIOLATION_TYPE_HASH_SCRIPT
501 // 3. Otherwise, report VIOLATION_TYPE_INLINE_SCRIPT if appropriate.
502 //
503 // 1 and 2 may occur together, 3 should only occur by itself. Naturally,
504 // every VIOLATION_TYPE_NONCE_SCRIPT and VIOLATION_TYPE_HASH_SCRIPT are also
505 // VIOLATION_TYPE_INLINE_SCRIPT, but reporting the
506 // VIOLATION_TYPE_INLINE_SCRIPT is redundant and does not help the developer.
507 if (!violations.IsEmpty()) {
508 MOZ_ASSERT(violations[0] == nsIContentSecurityPolicy::VIOLATION_TYPE_INLINE_SCRIPT,
509 "How did we get any violations without an initial inline script violation?");
510 // gather information to log with violation report
511 nsIURI* uri = aDocument->GetDocumentURI();
512 nsAutoCString asciiSpec;
513 uri->GetAsciiSpec(asciiSpec);
514 nsAutoString scriptText;
515 aElement->GetScriptText(scriptText);
516 nsAutoString scriptSample(scriptText);
517
518 // cap the length of the script sample at 40 chars
519 if (scriptSample.Length() > 40) {
520 scriptSample.Truncate(40);
521 scriptSample.AppendLiteral("...");
522 }
523
524 for (uint32_t i = 0; i < violations.Length(); i++) {
525 // Skip reporting the redundant inline script violation if there are
526 // other (nonce and/or hash violations) as well.
527 if (i > 0 || violations.Length() == 1) {
528 csp->LogViolationDetails(violations[i], NS_ConvertUTF8toUTF16(asciiSpec),
529 scriptSample, aElement->GetScriptLineNumber(),
530 nonce, scriptText);
531 }
532 }
533 }
534
535 if (!allowInlineScript) {
536 NS_ASSERTION(!violations.IsEmpty(),
537 "CSP blocked inline script but is not reporting a violation");
538 return false;
539 }
540 return true;
541 }
542
543 bool
544 nsScriptLoader::ProcessScriptElement(nsIScriptElement *aElement)
545 {
546 // We need a document to evaluate scripts.
547 NS_ENSURE_TRUE(mDocument, false);
548
549 // Check to see if scripts has been turned off.
550 if (!mEnabled || !mDocument->IsScriptEnabled()) {
551 return false;
552 }
553
554 NS_ASSERTION(!aElement->IsMalformed(), "Executing malformed script");
555
556 nsCOMPtr<nsIContent> scriptContent = do_QueryInterface(aElement);
557
558 // Step 12. Check that the script is not an eventhandler
559 if (IsScriptEventHandler(scriptContent)) {
560 return false;
561 }
562
563 JSVersion version = JSVERSION_DEFAULT;
564
565 // Check the type attribute to determine language and version.
566 // If type exists, it trumps the deprecated 'language='
567 nsAutoString type;
568 aElement->GetScriptType(type);
569 if (!type.IsEmpty()) {
570 NS_ENSURE_TRUE(ParseTypeAttribute(type, &version), false);
571 } else {
572 // no 'type=' element
573 // "language" is a deprecated attribute of HTML, so we check it only for
574 // HTML script elements.
575 if (scriptContent->IsHTML()) {
576 nsAutoString language;
577 scriptContent->GetAttr(kNameSpaceID_None, nsGkAtoms::language, language);
578 if (!language.IsEmpty()) {
579 if (!nsContentUtils::IsJavaScriptLanguage(language)) {
580 return false;
581 }
582 }
583 }
584 }
585
586 // Step 14. in the HTML5 spec
587 nsresult rv = NS_OK;
588 nsRefPtr<nsScriptLoadRequest> request;
589 if (aElement->GetScriptExternal()) {
590 // external script
591 nsCOMPtr<nsIURI> scriptURI = aElement->GetScriptURI();
592 if (!scriptURI) {
593 // Asynchronously report the failure to create a URI object
594 NS_DispatchToCurrentThread(
595 NS_NewRunnableMethod(aElement,
596 &nsIScriptElement::FireErrorEvent));
597 return false;
598 }
599 CORSMode ourCORSMode = aElement->GetCORSMode();
600 nsTArray<PreloadInfo>::index_type i =
601 mPreloads.IndexOf(scriptURI.get(), 0, PreloadURIComparator());
602 if (i != nsTArray<PreloadInfo>::NoIndex) {
603 // preloaded
604 // note that a script-inserted script can steal a preload!
605 request = mPreloads[i].mRequest;
606 request->mElement = aElement;
607 nsString preloadCharset(mPreloads[i].mCharset);
608 mPreloads.RemoveElementAt(i);
609
610 // Double-check that the charset the preload used is the same as
611 // the charset we have now.
612 nsAutoString elementCharset;
613 aElement->GetScriptCharset(elementCharset);
614 if (elementCharset.Equals(preloadCharset) &&
615 ourCORSMode == request->mCORSMode) {
616 rv = CheckContentPolicy(mDocument, aElement, request->mURI, type);
617 NS_ENSURE_SUCCESS(rv, false);
618 } else {
619 // Drop the preload
620 request = nullptr;
621 }
622 }
623
624 if (!request) {
625 // no usable preload
626 request = new nsScriptLoadRequest(aElement, version, ourCORSMode);
627 request->mURI = scriptURI;
628 request->mIsInline = false;
629 request->mLoading = true;
630
631 // set aScriptFromHead to false so we don't treat non preloaded scripts as
632 // blockers for full page load. See bug 792438.
633 rv = StartLoad(request, type, false);
634 if (NS_FAILED(rv)) {
635 // Asynchronously report the load failure
636 NS_DispatchToCurrentThread(
637 NS_NewRunnableMethod(aElement,
638 &nsIScriptElement::FireErrorEvent));
639 return false;
640 }
641 }
642
643 request->mJSVersion = version;
644
645 if (aElement->GetScriptAsync()) {
646 mAsyncRequests.AppendElement(request);
647 if (!request->mLoading) {
648 // The script is available already. Run it ASAP when the event
649 // loop gets a chance to spin.
650 ProcessPendingRequestsAsync();
651 }
652 return false;
653 }
654 if (!aElement->GetParserCreated()) {
655 // Violate the HTML5 spec in order to make LABjs and the "order" plug-in
656 // for RequireJS work with their Gecko-sniffed code path. See
657 // http://lists.w3.org/Archives/Public/public-html/2010Oct/0088.html
658 mNonAsyncExternalScriptInsertedRequests.AppendElement(request);
659 if (!request->mLoading) {
660 // The script is available already. Run it ASAP when the event
661 // loop gets a chance to spin.
662 ProcessPendingRequestsAsync();
663 }
664 return false;
665 }
666 // we now have a parser-inserted request that may or may not be still
667 // loading
668 if (aElement->GetScriptDeferred()) {
669 // We don't want to run this yet.
670 // If we come here, the script is a parser-created script and it has
671 // the defer attribute but not the async attribute. Since a
672 // a parser-inserted script is being run, we came here by the parser
673 // running the script, which means the parser is still alive and the
674 // parse is ongoing.
675 NS_ASSERTION(mDocument->GetCurrentContentSink() ||
676 aElement->GetParserCreated() == FROM_PARSER_XSLT,
677 "Non-XSLT Defer script on a document without an active parser; bug 592366.");
678 AddDeferRequest(request);
679 return false;
680 }
681
682 if (aElement->GetParserCreated() == FROM_PARSER_XSLT) {
683 // Need to maintain order for XSLT-inserted scripts
684 NS_ASSERTION(!mParserBlockingRequest,
685 "Parser-blocking scripts and XSLT scripts in the same doc!");
686 mXSLTRequests.AppendElement(request);
687 if (!request->mLoading) {
688 // The script is available already. Run it ASAP when the event
689 // loop gets a chance to spin.
690 ProcessPendingRequestsAsync();
691 }
692 return true;
693 }
694 if (!request->mLoading && ReadyToExecuteScripts()) {
695 // The request has already been loaded and there are no pending style
696 // sheets. If the script comes from the network stream, cheat for
697 // performance reasons and avoid a trip through the event loop.
698 if (aElement->GetParserCreated() == FROM_PARSER_NETWORK) {
699 return ProcessRequest(request) == NS_ERROR_HTMLPARSER_BLOCK;
700 }
701 // Otherwise, we've got a document.written script, make a trip through
702 // the event loop to hide the preload effects from the scripts on the
703 // Web page.
704 NS_ASSERTION(!mParserBlockingRequest,
705 "There can be only one parser-blocking script at a time");
706 NS_ASSERTION(mXSLTRequests.IsEmpty(),
707 "Parser-blocking scripts and XSLT scripts in the same doc!");
708 mParserBlockingRequest = request;
709 ProcessPendingRequestsAsync();
710 return true;
711 }
712 // The script hasn't loaded yet or there's a style sheet blocking it.
713 // The script will be run when it loads or the style sheet loads.
714 NS_ASSERTION(!mParserBlockingRequest,
715 "There can be only one parser-blocking script at a time");
716 NS_ASSERTION(mXSLTRequests.IsEmpty(),
717 "Parser-blocking scripts and XSLT scripts in the same doc!");
718 mParserBlockingRequest = request;
719 return true;
720 }
721
722 // inline script
723 // Is this document sandboxed without 'allow-scripts'?
724 if (mDocument->GetSandboxFlags() & SANDBOXED_SCRIPTS) {
725 return false;
726 }
727
728 // Does CSP allow this inline script to run?
729 if (!CSPAllowsInlineScript(aElement, mDocument)) {
730 return false;
731 }
732
733 // Inline scripts ignore ther CORS mode and are always CORS_NONE
734 request = new nsScriptLoadRequest(aElement, version, CORS_NONE);
735 request->mJSVersion = version;
736 request->mLoading = false;
737 request->mIsInline = true;
738 request->mURI = mDocument->GetDocumentURI();
739 request->mLineNo = aElement->GetScriptLineNumber();
740
741 if (aElement->GetParserCreated() == FROM_PARSER_XSLT &&
742 (!ReadyToExecuteScripts() || !mXSLTRequests.IsEmpty())) {
743 // Need to maintain order for XSLT-inserted scripts
744 NS_ASSERTION(!mParserBlockingRequest,
745 "Parser-blocking scripts and XSLT scripts in the same doc!");
746 mXSLTRequests.AppendElement(request);
747 return true;
748 }
749 if (aElement->GetParserCreated() == NOT_FROM_PARSER) {
750 NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
751 "A script-inserted script is inserted without an update batch?");
752 nsContentUtils::AddScriptRunner(new nsScriptRequestProcessor(this,
753 request));
754 return false;
755 }
756 if (aElement->GetParserCreated() == FROM_PARSER_NETWORK &&
757 !ReadyToExecuteScripts()) {
758 NS_ASSERTION(!mParserBlockingRequest,
759 "There can be only one parser-blocking script at a time");
760 mParserBlockingRequest = request;
761 NS_ASSERTION(mXSLTRequests.IsEmpty(),
762 "Parser-blocking scripts and XSLT scripts in the same doc!");
763 return true;
764 }
765 // We now have a document.written inline script or we have an inline script
766 // from the network but there is no style sheet that is blocking scripts.
767 // Don't check for style sheets blocking scripts in the document.write
768 // case to avoid style sheet network activity affecting when
769 // document.write returns. It's not really necessary to do this if
770 // there's no document.write currently on the call stack. However,
771 // this way matches IE more closely than checking if document.write
772 // is on the call stack.
773 NS_ASSERTION(nsContentUtils::IsSafeToRunScript(),
774 "Not safe to run a parser-inserted script?");
775 return ProcessRequest(request) == NS_ERROR_HTMLPARSER_BLOCK;
776 }
777
778 namespace {
779
780 class NotifyOffThreadScriptLoadCompletedRunnable : public nsRunnable
781 {
782 nsRefPtr<nsScriptLoadRequest> mRequest;
783 nsRefPtr<nsScriptLoader> mLoader;
784 void *mToken;
785
786 public:
787 NotifyOffThreadScriptLoadCompletedRunnable(nsScriptLoadRequest* aRequest,
788 nsScriptLoader* aLoader)
789 : mRequest(aRequest), mLoader(aLoader), mToken(nullptr)
790 {}
791
792 void SetToken(void* aToken) {
793 MOZ_ASSERT(aToken && !mToken);
794 mToken = aToken;
795 }
796
797 NS_DECL_NSIRUNNABLE
798 };
799
800 } /* anonymous namespace */
801
802 nsresult
803 nsScriptLoader::ProcessOffThreadRequest(nsScriptLoadRequest* aRequest, void **aOffThreadToken)
804 {
805 nsresult rv = ProcessRequest(aRequest, aOffThreadToken);
806 mDocument->UnblockOnload(false);
807 return rv;
808 }
809
810 NS_IMETHODIMP
811 NotifyOffThreadScriptLoadCompletedRunnable::Run()
812 {
813 MOZ_ASSERT(NS_IsMainThread());
814
815 nsresult rv = mLoader->ProcessOffThreadRequest(mRequest, &mToken);
816
817 if (mToken) {
818 // The result of the off thread parse was not actually needed to process
819 // the request (disappearing window, some other error, ...). Finish the
820 // request to avoid leaks in the JS engine.
821 nsCOMPtr<nsIJSRuntimeService> svc = do_GetService("@mozilla.org/js/xpc/RuntimeService;1");
822 NS_ENSURE_TRUE(svc, NS_ERROR_FAILURE);
823 JSRuntime *rt;
824 svc->GetRuntime(&rt);
825 NS_ENSURE_TRUE(rt, NS_ERROR_FAILURE);
826 JS::FinishOffThreadScript(nullptr, rt, mToken);
827 }
828
829 return rv;
830 }
831
832 static void
833 OffThreadScriptLoaderCallback(void *aToken, void *aCallbackData)
834 {
835 nsRefPtr<NotifyOffThreadScriptLoadCompletedRunnable> aRunnable =
836 dont_AddRef(static_cast<NotifyOffThreadScriptLoadCompletedRunnable*>(aCallbackData));
837 aRunnable->SetToken(aToken);
838 NS_DispatchToMainThread(aRunnable);
839 }
840
841 nsresult
842 nsScriptLoader::AttemptAsyncScriptParse(nsScriptLoadRequest* aRequest)
843 {
844 if (!aRequest->mElement->GetScriptAsync() || aRequest->mIsInline) {
845 return NS_ERROR_FAILURE;
846 }
847
848 nsCOMPtr<nsIScriptGlobalObject> globalObject = GetScriptGlobalObject();
849 if (!globalObject) {
850 return NS_ERROR_FAILURE;
851 }
852
853 nsCOMPtr<nsIScriptContext> context = globalObject->GetScriptContext();
854 if (!context) {
855 return NS_ERROR_FAILURE;
856 }
857
858 AutoPushJSContext cx(context->GetNativeContext());
859 JS::Rooted<JSObject*> global(cx, globalObject->GetGlobalJSObject());
860
861 JS::CompileOptions options(cx);
862 FillCompileOptionsForRequest(aRequest, global, &options);
863
864 if (!JS::CanCompileOffThread(cx, options, aRequest->mScriptTextLength)) {
865 return NS_ERROR_FAILURE;
866 }
867
868 nsRefPtr<NotifyOffThreadScriptLoadCompletedRunnable> runnable =
869 new NotifyOffThreadScriptLoadCompletedRunnable(aRequest, this);
870
871 if (!JS::CompileOffThread(cx, options,
872 aRequest->mScriptTextBuf, aRequest->mScriptTextLength,
873 OffThreadScriptLoaderCallback,
874 static_cast<void*>(runnable))) {
875 return NS_ERROR_OUT_OF_MEMORY;
876 }
877
878 mDocument->BlockOnload();
879
880 unused << runnable.forget();
881 return NS_OK;
882 }
883
884 nsresult
885 nsScriptLoader::ProcessRequest(nsScriptLoadRequest* aRequest, void **aOffThreadToken)
886 {
887 NS_ASSERTION(nsContentUtils::IsSafeToRunScript(),
888 "Processing requests when running scripts is unsafe.");
889
890 if (!aOffThreadToken) {
891 nsresult rv = AttemptAsyncScriptParse(aRequest);
892 if (rv != NS_ERROR_FAILURE)
893 return rv;
894 }
895
896 NS_ENSURE_ARG(aRequest);
897 nsAutoString textData;
898 const jschar* scriptBuf = nullptr;
899 size_t scriptLength = 0;
900 JS::SourceBufferHolder::Ownership giveScriptOwnership =
901 JS::SourceBufferHolder::NoOwnership;
902
903 nsCOMPtr<nsIDocument> doc;
904
905 nsCOMPtr<nsINode> scriptElem = do_QueryInterface(aRequest->mElement);
906
907 // If there's no script text, we try to get it from the element
908 if (aRequest->mIsInline) {
909 // XXX This is inefficient - GetText makes multiple
910 // copies.
911 aRequest->mElement->GetScriptText(textData);
912
913 scriptBuf = textData.get();
914 scriptLength = textData.Length();
915 giveScriptOwnership = JS::SourceBufferHolder::NoOwnership;
916 }
917 else {
918 scriptBuf = aRequest->mScriptTextBuf;
919 scriptLength = aRequest->mScriptTextLength;
920
921 giveScriptOwnership = JS::SourceBufferHolder::GiveOwnership;
922 aRequest->mScriptTextBuf = nullptr;
923 aRequest->mScriptTextLength = 0;
924
925 doc = scriptElem->OwnerDoc();
926 }
927
928 JS::SourceBufferHolder srcBuf(scriptBuf, scriptLength, giveScriptOwnership);
929
930 nsCOMPtr<nsIScriptElement> oldParserInsertedScript;
931 uint32_t parserCreated = aRequest->mElement->GetParserCreated();
932 if (parserCreated) {
933 oldParserInsertedScript = mCurrentParserInsertedScript;
934 mCurrentParserInsertedScript = aRequest->mElement;
935 }
936
937 FireScriptAvailable(NS_OK, aRequest);
938
939 // The window may have gone away by this point, in which case there's no point
940 // in trying to run the script.
941 nsPIDOMWindow *pwin = mDocument->GetInnerWindow();
942 bool runScript = !!pwin;
943 if (runScript) {
944 nsContentUtils::DispatchTrustedEvent(scriptElem->OwnerDoc(),
945 scriptElem,
946 NS_LITERAL_STRING("beforescriptexecute"),
947 true, true, &runScript);
948 }
949
950 // Inner window could have gone away after firing beforescriptexecute
951 pwin = mDocument->GetInnerWindow();
952 if (!pwin) {
953 runScript = false;
954 }
955
956 nsresult rv = NS_OK;
957 if (runScript) {
958 if (doc) {
959 doc->BeginEvaluatingExternalScript();
960 }
961 aRequest->mElement->BeginEvaluating();
962 rv = EvaluateScript(aRequest, srcBuf, aOffThreadToken);
963 aRequest->mElement->EndEvaluating();
964 if (doc) {
965 doc->EndEvaluatingExternalScript();
966 }
967
968 nsContentUtils::DispatchTrustedEvent(scriptElem->OwnerDoc(),
969 scriptElem,
970 NS_LITERAL_STRING("afterscriptexecute"),
971 true, false);
972 }
973
974 FireScriptEvaluated(rv, aRequest);
975
976 if (parserCreated) {
977 mCurrentParserInsertedScript = oldParserInsertedScript;
978 }
979
980 return rv;
981 }
982
983 void
984 nsScriptLoader::FireScriptAvailable(nsresult aResult,
985 nsScriptLoadRequest* aRequest)
986 {
987 for (int32_t i = 0; i < mObservers.Count(); i++) {
988 nsCOMPtr<nsIScriptLoaderObserver> obs = mObservers[i];
989 obs->ScriptAvailable(aResult, aRequest->mElement,
990 aRequest->mIsInline, aRequest->mURI,
991 aRequest->mLineNo);
992 }
993
994 aRequest->FireScriptAvailable(aResult);
995 }
996
997 void
998 nsScriptLoader::FireScriptEvaluated(nsresult aResult,
999 nsScriptLoadRequest* aRequest)
1000 {
1001 for (int32_t i = 0; i < mObservers.Count(); i++) {
1002 nsCOMPtr<nsIScriptLoaderObserver> obs = mObservers[i];
1003 obs->ScriptEvaluated(aResult, aRequest->mElement,
1004 aRequest->mIsInline);
1005 }
1006
1007 aRequest->FireScriptEvaluated(aResult);
1008 }
1009
1010 already_AddRefed<nsIScriptGlobalObject>
1011 nsScriptLoader::GetScriptGlobalObject()
1012 {
1013 nsPIDOMWindow *pwin = mDocument->GetInnerWindow();
1014 if (!pwin) {
1015 return nullptr;
1016 }
1017
1018 nsCOMPtr<nsIScriptGlobalObject> globalObject = do_QueryInterface(pwin);
1019 NS_ASSERTION(globalObject, "windows must be global objects");
1020
1021 // and make sure we are setup for this type of script.
1022 nsresult rv = globalObject->EnsureScriptEnvironment();
1023 if (NS_FAILED(rv)) {
1024 return nullptr;
1025 }
1026
1027 return globalObject.forget();
1028 }
1029
1030 void
1031 nsScriptLoader::FillCompileOptionsForRequest(nsScriptLoadRequest *aRequest,
1032 JS::Handle<JSObject *> aScopeChain,
1033 JS::CompileOptions *aOptions)
1034 {
1035 // It's very important to use aRequest->mURI, not the final URI of the channel
1036 // aRequest ended up getting script data from, as the script filename.
1037 nsContentUtils::GetWrapperSafeScriptFilename(mDocument, aRequest->mURI, aRequest->mURL);
1038
1039 aOptions->setIntroductionType("scriptElement");
1040 aOptions->setFileAndLine(aRequest->mURL.get(), aRequest->mLineNo);
1041 aOptions->setVersion(JSVersion(aRequest->mJSVersion));
1042 aOptions->setCompileAndGo(JS_IsGlobalObject(aScopeChain));
1043 if (aRequest->mHasSourceMapURL) {
1044 aOptions->setSourceMapURL(aRequest->mSourceMapURL.get());
1045 }
1046 if (aRequest->mOriginPrincipal) {
1047 aOptions->setOriginPrincipals(nsJSPrincipals::get(aRequest->mOriginPrincipal));
1048 }
1049
1050 AutoJSContext cx;
1051 JS::Rooted<JS::Value> elementVal(cx);
1052 MOZ_ASSERT(aRequest->mElement);
1053 // XXXbz this is super-fragile, because the code that _uses_ the
1054 // JS::CompileOptions is nowhere near us, but we have to coordinate
1055 // compartments with it... and in particular, it will compile in the
1056 // compartment of aScopeChain, so we want to wrap into that compartment as
1057 // well.
1058 JSAutoCompartment ac(cx, aScopeChain);
1059 if (NS_SUCCEEDED(nsContentUtils::WrapNative(cx, aRequest->mElement,
1060 &elementVal,
1061 /* aAllowWrapping = */ true))) {
1062 MOZ_ASSERT(elementVal.isObject());
1063 aOptions->setElement(&elementVal.toObject());
1064 }
1065 }
1066
1067 nsresult
1068 nsScriptLoader::EvaluateScript(nsScriptLoadRequest* aRequest,
1069 JS::SourceBufferHolder& aSrcBuf,
1070 void** aOffThreadToken)
1071 {
1072 // We need a document to evaluate scripts.
1073 if (!mDocument) {
1074 return NS_ERROR_FAILURE;
1075 }
1076
1077 nsCOMPtr<nsIContent> scriptContent(do_QueryInterface(aRequest->mElement));
1078 nsIDocument* ownerDoc = scriptContent->OwnerDoc();
1079 if (ownerDoc != mDocument) {
1080 // Willful violation of HTML5 as of 2010-12-01
1081 return NS_ERROR_FAILURE;
1082 }
1083
1084 // Get the script-type to be used by this element.
1085 NS_ASSERTION(scriptContent, "no content - what is default script-type?");
1086
1087 nsCOMPtr<nsIScriptGlobalObject> globalObject = GetScriptGlobalObject();
1088 if (!globalObject) {
1089 return NS_ERROR_FAILURE;
1090 }
1091
1092 // Make sure context is a strong reference since we access it after
1093 // we've executed a script, which may cause all other references to
1094 // the context to go away.
1095 nsCOMPtr<nsIScriptContext> context = globalObject->GetScriptContext();
1096 if (!context) {
1097 return NS_ERROR_FAILURE;
1098 }
1099
1100 JSVersion version = JSVersion(aRequest->mJSVersion);
1101 if (version == JSVERSION_UNKNOWN) {
1102 return NS_OK;
1103 }
1104
1105 // New script entry point required, due to the "Create a script" sub-step of
1106 // http://www.whatwg.org/specs/web-apps/current-work/#execute-the-script-block
1107 AutoEntryScript entryScript(globalObject, true, context->GetNativeContext());
1108 JS::Rooted<JSObject*> global(entryScript.cx(),
1109 globalObject->GetGlobalJSObject());
1110
1111 bool oldProcessingScriptTag = context->GetProcessingScriptTag();
1112 context->SetProcessingScriptTag(true);
1113
1114 // Update our current script.
1115 nsCOMPtr<nsIScriptElement> oldCurrent = mCurrentScript;
1116 mCurrentScript = aRequest->mElement;
1117
1118 JS::CompileOptions options(entryScript.cx());
1119 FillCompileOptionsForRequest(aRequest, global, &options);
1120 nsresult rv = nsJSUtils::EvaluateString(entryScript.cx(), aSrcBuf, global, options,
1121 aOffThreadToken);
1122
1123 // Put the old script back in case it wants to do anything else.
1124 mCurrentScript = oldCurrent;
1125
1126 context->SetProcessingScriptTag(oldProcessingScriptTag);
1127 return rv;
1128 }
1129
1130 void
1131 nsScriptLoader::ProcessPendingRequestsAsync()
1132 {
1133 if (mParserBlockingRequest || !mPendingChildLoaders.IsEmpty()) {
1134 nsCOMPtr<nsIRunnable> ev = NS_NewRunnableMethod(this,
1135 &nsScriptLoader::ProcessPendingRequests);
1136
1137 NS_DispatchToCurrentThread(ev);
1138 }
1139 }
1140
1141 void
1142 nsScriptLoader::ProcessPendingRequests()
1143 {
1144 nsRefPtr<nsScriptLoadRequest> request;
1145 if (mParserBlockingRequest &&
1146 !mParserBlockingRequest->mLoading &&
1147 ReadyToExecuteScripts()) {
1148 request.swap(mParserBlockingRequest);
1149 UnblockParser(request);
1150 ProcessRequest(request);
1151 ContinueParserAsync(request);
1152 }
1153
1154 while (ReadyToExecuteScripts() &&
1155 !mXSLTRequests.IsEmpty() &&
1156 !mXSLTRequests[0]->mLoading) {
1157 request.swap(mXSLTRequests[0]);
1158 mXSLTRequests.RemoveElementAt(0);
1159 ProcessRequest(request);
1160 }
1161
1162 uint32_t i = 0;
1163 while (mEnabled && i < mAsyncRequests.Length()) {
1164 if (!mAsyncRequests[i]->mLoading) {
1165 request.swap(mAsyncRequests[i]);
1166 mAsyncRequests.RemoveElementAt(i);
1167 ProcessRequest(request);
1168 continue;
1169 }
1170 ++i;
1171 }
1172
1173 while (mEnabled && !mNonAsyncExternalScriptInsertedRequests.IsEmpty() &&
1174 !mNonAsyncExternalScriptInsertedRequests[0]->mLoading) {
1175 // Violate the HTML5 spec and execute these in the insertion order in
1176 // order to make LABjs and the "order" plug-in for RequireJS work with
1177 // their Gecko-sniffed code path. See
1178 // http://lists.w3.org/Archives/Public/public-html/2010Oct/0088.html
1179 request.swap(mNonAsyncExternalScriptInsertedRequests[0]);
1180 mNonAsyncExternalScriptInsertedRequests.RemoveElementAt(0);
1181 ProcessRequest(request);
1182 }
1183
1184 if (mDocumentParsingDone && mXSLTRequests.IsEmpty()) {
1185 while (!mDeferRequests.IsEmpty() && !mDeferRequests[0]->mLoading) {
1186 request.swap(mDeferRequests[0]);
1187 mDeferRequests.RemoveElementAt(0);
1188 ProcessRequest(request);
1189 }
1190 }
1191
1192 while (!mPendingChildLoaders.IsEmpty() && ReadyToExecuteScripts()) {
1193 nsRefPtr<nsScriptLoader> child = mPendingChildLoaders[0];
1194 mPendingChildLoaders.RemoveElementAt(0);
1195 child->RemoveExecuteBlocker();
1196 }
1197
1198 if (mDocumentParsingDone && mDocument &&
1199 !mParserBlockingRequest && mAsyncRequests.IsEmpty() &&
1200 mNonAsyncExternalScriptInsertedRequests.IsEmpty() &&
1201 mXSLTRequests.IsEmpty() && mDeferRequests.IsEmpty()) {
1202 if (MaybeRemovedDeferRequests()) {
1203 return ProcessPendingRequests();
1204 }
1205 // No more pending scripts; time to unblock onload.
1206 // OK to unblock onload synchronously here, since callers must be
1207 // prepared for the world changing anyway.
1208 mDocumentParsingDone = false;
1209 mDocument->UnblockOnload(true);
1210 }
1211 }
1212
1213 bool
1214 nsScriptLoader::ReadyToExecuteScripts()
1215 {
1216 // Make sure the SelfReadyToExecuteScripts check is first, so that
1217 // we don't block twice on an ancestor.
1218 if (!SelfReadyToExecuteScripts()) {
1219 return false;
1220 }
1221
1222 for (nsIDocument* doc = mDocument; doc; doc = doc->GetParentDocument()) {
1223 nsScriptLoader* ancestor = doc->ScriptLoader();
1224 if (!ancestor->SelfReadyToExecuteScripts() &&
1225 ancestor->AddPendingChildLoader(this)) {
1226 AddExecuteBlocker();
1227 return false;
1228 }
1229 }
1230
1231 return true;
1232 }
1233
1234
1235 // This function was copied from nsParser.cpp. It was simplified a bit.
1236 static bool
1237 DetectByteOrderMark(const unsigned char* aBytes, int32_t aLen, nsCString& oCharset)
1238 {
1239 if (aLen < 2)
1240 return false;
1241
1242 switch(aBytes[0]) {
1243 case 0xEF:
1244 if (aLen >= 3 && 0xBB == aBytes[1] && 0xBF == aBytes[2]) {
1245 // EF BB BF
1246 // Win2K UTF-8 BOM
1247 oCharset.Assign("UTF-8");
1248 }
1249 break;
1250 case 0xFE:
1251 if (0xFF == aBytes[1]) {
1252 // FE FF
1253 // UTF-16, big-endian
1254 oCharset.Assign("UTF-16BE");
1255 }
1256 break;
1257 case 0xFF:
1258 if (0xFE == aBytes[1]) {
1259 // FF FE
1260 // UTF-16, little-endian
1261 oCharset.Assign("UTF-16LE");
1262 }
1263 break;
1264 }
1265 return !oCharset.IsEmpty();
1266 }
1267
1268 /* static */ nsresult
1269 nsScriptLoader::ConvertToUTF16(nsIChannel* aChannel, const uint8_t* aData,
1270 uint32_t aLength, const nsAString& aHintCharset,
1271 nsIDocument* aDocument,
1272 jschar*& aBufOut, size_t& aLengthOut)
1273 {
1274 if (!aLength) {
1275 aBufOut = nullptr;
1276 aLengthOut = 0;
1277 return NS_OK;
1278 }
1279
1280 // The encoding info precedence is as follows from high to low:
1281 // The BOM
1282 // HTTP Content-Type (if name recognized)
1283 // charset attribute (if name recognized)
1284 // The encoding of the document
1285
1286 nsAutoCString charset;
1287
1288 nsCOMPtr<nsIUnicodeDecoder> unicodeDecoder;
1289
1290 if (DetectByteOrderMark(aData, aLength, charset)) {
1291 // charset is now "UTF-8" or "UTF-16". The UTF-16 decoder will re-sniff
1292 // the BOM for endianness. Both the UTF-16 and the UTF-8 decoder will
1293 // take care of swallowing the BOM.
1294 unicodeDecoder = EncodingUtils::DecoderForEncoding(charset);
1295 }
1296
1297 if (!unicodeDecoder &&
1298 aChannel &&
1299 NS_SUCCEEDED(aChannel->GetContentCharset(charset)) &&
1300 EncodingUtils::FindEncodingForLabel(charset, charset)) {
1301 unicodeDecoder = EncodingUtils::DecoderForEncoding(charset);
1302 }
1303
1304 if (!unicodeDecoder &&
1305 EncodingUtils::FindEncodingForLabel(aHintCharset, charset)) {
1306 unicodeDecoder = EncodingUtils::DecoderForEncoding(charset);
1307 }
1308
1309 if (!unicodeDecoder && aDocument) {
1310 charset = aDocument->GetDocumentCharacterSet();
1311 unicodeDecoder = EncodingUtils::DecoderForEncoding(charset);
1312 }
1313
1314 if (!unicodeDecoder) {
1315 // Curiously, there are various callers that don't pass aDocument. The
1316 // fallback in the old code was ISO-8859-1, which behaved like
1317 // windows-1252. Saying windows-1252 for clarity and for compliance
1318 // with the Encoding Standard.
1319 unicodeDecoder = EncodingUtils::DecoderForEncoding("windows-1252");
1320 }
1321
1322 int32_t unicodeLength = 0;
1323
1324 nsresult rv =
1325 unicodeDecoder->GetMaxLength(reinterpret_cast<const char*>(aData),
1326 aLength, &unicodeLength);
1327 NS_ENSURE_SUCCESS(rv, rv);
1328
1329 aBufOut = static_cast<jschar*>(js_malloc(unicodeLength * sizeof(jschar)));
1330 if (!aBufOut) {
1331 aLengthOut = 0;
1332 return NS_ERROR_OUT_OF_MEMORY;
1333 }
1334 aLengthOut = unicodeLength;
1335
1336 rv = unicodeDecoder->Convert(reinterpret_cast<const char*>(aData),
1337 (int32_t *) &aLength, aBufOut,
1338 &unicodeLength);
1339 MOZ_ASSERT(NS_SUCCEEDED(rv));
1340 aLengthOut = unicodeLength;
1341 if (NS_FAILED(rv)) {
1342 js_free(aBufOut);
1343 aBufOut = nullptr;
1344 aLengthOut = 0;
1345 }
1346 return rv;
1347 }
1348
1349 NS_IMETHODIMP
1350 nsScriptLoader::OnStreamComplete(nsIStreamLoader* aLoader,
1351 nsISupports* aContext,
1352 nsresult aStatus,
1353 uint32_t aStringLen,
1354 const uint8_t* aString)
1355 {
1356 nsScriptLoadRequest* request = static_cast<nsScriptLoadRequest*>(aContext);
1357 NS_ASSERTION(request, "null request in stream complete handler");
1358 NS_ENSURE_TRUE(request, NS_ERROR_FAILURE);
1359
1360 nsresult rv = PrepareLoadedRequest(request, aLoader, aStatus, aStringLen,
1361 aString);
1362 if (NS_FAILED(rv)) {
1363 if (mDeferRequests.RemoveElement(request) ||
1364 mAsyncRequests.RemoveElement(request) ||
1365 mNonAsyncExternalScriptInsertedRequests.RemoveElement(request) ||
1366 mXSLTRequests.RemoveElement(request)) {
1367 FireScriptAvailable(rv, request);
1368 } else if (mParserBlockingRequest == request) {
1369 mParserBlockingRequest = nullptr;
1370 UnblockParser(request);
1371 FireScriptAvailable(rv, request);
1372 ContinueParserAsync(request);
1373 } else {
1374 mPreloads.RemoveElement(request, PreloadRequestComparator());
1375 }
1376 rv = NS_OK;
1377 } else {
1378 NS_Free(const_cast<uint8_t *>(aString));
1379 rv = NS_SUCCESS_ADOPTED_DATA;
1380 }
1381
1382 // Process our request and/or any pending ones
1383 ProcessPendingRequests();
1384
1385 return rv;
1386 }
1387
1388 void
1389 nsScriptLoader::UnblockParser(nsScriptLoadRequest* aParserBlockingRequest)
1390 {
1391 aParserBlockingRequest->mElement->UnblockParser();
1392 }
1393
1394 void
1395 nsScriptLoader::ContinueParserAsync(nsScriptLoadRequest* aParserBlockingRequest)
1396 {
1397 aParserBlockingRequest->mElement->ContinueParserAsync();
1398 }
1399
1400 nsresult
1401 nsScriptLoader::PrepareLoadedRequest(nsScriptLoadRequest* aRequest,
1402 nsIStreamLoader* aLoader,
1403 nsresult aStatus,
1404 uint32_t aStringLen,
1405 const uint8_t* aString)
1406 {
1407 if (NS_FAILED(aStatus)) {
1408 return aStatus;
1409 }
1410
1411 // If we don't have a document, then we need to abort further
1412 // evaluation.
1413 if (!mDocument) {
1414 return NS_ERROR_NOT_AVAILABLE;
1415 }
1416
1417 // If the load returned an error page, then we need to abort
1418 nsCOMPtr<nsIRequest> req;
1419 nsresult rv = aLoader->GetRequest(getter_AddRefs(req));
1420 NS_ASSERTION(req, "StreamLoader's request went away prematurely");
1421 NS_ENSURE_SUCCESS(rv, rv);
1422
1423 nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(req);
1424 if (httpChannel) {
1425 bool requestSucceeded;
1426 rv = httpChannel->GetRequestSucceeded(&requestSucceeded);
1427 if (NS_SUCCEEDED(rv) && !requestSucceeded) {
1428 return NS_ERROR_NOT_AVAILABLE;
1429 }
1430
1431 nsAutoCString sourceMapURL;
1432 httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("X-SourceMap"), sourceMapURL);
1433 aRequest->mHasSourceMapURL = true;
1434 aRequest->mSourceMapURL = NS_ConvertUTF8toUTF16(sourceMapURL);
1435 }
1436
1437 nsCOMPtr<nsIChannel> channel = do_QueryInterface(req);
1438 // If this load was subject to a CORS check; don't flag it with a
1439 // separate origin principal, so that it will treat our document's
1440 // principal as the origin principal
1441 if (aRequest->mCORSMode == CORS_NONE) {
1442 rv = nsContentUtils::GetSecurityManager()->
1443 GetChannelPrincipal(channel, getter_AddRefs(aRequest->mOriginPrincipal));
1444 NS_ENSURE_SUCCESS(rv, rv);
1445 }
1446
1447 if (aStringLen) {
1448 // Check the charset attribute to determine script charset.
1449 nsAutoString hintCharset;
1450 if (!aRequest->IsPreload()) {
1451 aRequest->mElement->GetScriptCharset(hintCharset);
1452 } else {
1453 nsTArray<PreloadInfo>::index_type i =
1454 mPreloads.IndexOf(aRequest, 0, PreloadRequestComparator());
1455 NS_ASSERTION(i != mPreloads.NoIndex, "Incorrect preload bookkeeping");
1456 hintCharset = mPreloads[i].mCharset;
1457 }
1458 rv = ConvertToUTF16(channel, aString, aStringLen, hintCharset, mDocument,
1459 aRequest->mScriptTextBuf, aRequest->mScriptTextLength);
1460
1461 NS_ENSURE_SUCCESS(rv, rv);
1462 }
1463
1464 // This assertion could fire errorously if we ran out of memory when
1465 // inserting the request in the array. However it's an unlikely case
1466 // so if you see this assertion it is likely something else that is
1467 // wrong, especially if you see it more than once.
1468 NS_ASSERTION(mDeferRequests.Contains(aRequest) ||
1469 mAsyncRequests.Contains(aRequest) ||
1470 mNonAsyncExternalScriptInsertedRequests.Contains(aRequest) ||
1471 mXSLTRequests.Contains(aRequest) ||
1472 mPreloads.Contains(aRequest, PreloadRequestComparator()) ||
1473 mParserBlockingRequest,
1474 "aRequest should be pending!");
1475
1476 // Mark this as loaded
1477 aRequest->mLoading = false;
1478
1479 return NS_OK;
1480 }
1481
1482 void
1483 nsScriptLoader::ParsingComplete(bool aTerminated)
1484 {
1485 if (mDeferEnabled) {
1486 // Have to check because we apparently get ParsingComplete
1487 // without BeginDeferringScripts in some cases
1488 mDocumentParsingDone = true;
1489 }
1490 mDeferEnabled = false;
1491 if (aTerminated) {
1492 mDeferRequests.Clear();
1493 mAsyncRequests.Clear();
1494 mNonAsyncExternalScriptInsertedRequests.Clear();
1495 mXSLTRequests.Clear();
1496 mParserBlockingRequest = nullptr;
1497 }
1498
1499 // Have to call this even if aTerminated so we'll correctly unblock
1500 // onload and all.
1501 ProcessPendingRequests();
1502 }
1503
1504 void
1505 nsScriptLoader::PreloadURI(nsIURI *aURI, const nsAString &aCharset,
1506 const nsAString &aType,
1507 const nsAString &aCrossOrigin,
1508 bool aScriptFromHead)
1509 {
1510 // Check to see if scripts has been turned off.
1511 if (!mEnabled || !mDocument->IsScriptEnabled()) {
1512 return;
1513 }
1514
1515 nsRefPtr<nsScriptLoadRequest> request =
1516 new nsScriptLoadRequest(nullptr, 0,
1517 Element::StringToCORSMode(aCrossOrigin));
1518 request->mURI = aURI;
1519 request->mIsInline = false;
1520 request->mLoading = true;
1521 nsresult rv = StartLoad(request, aType, aScriptFromHead);
1522 if (NS_FAILED(rv)) {
1523 return;
1524 }
1525
1526 PreloadInfo *pi = mPreloads.AppendElement();
1527 pi->mRequest = request;
1528 pi->mCharset = aCharset;
1529 }
1530
1531 void
1532 nsScriptLoader::AddDeferRequest(nsScriptLoadRequest* aRequest)
1533 {
1534 mDeferRequests.AppendElement(aRequest);
1535 if (mDeferEnabled && mDeferRequests.Length() == 1 && mDocument &&
1536 !mBlockingDOMContentLoaded) {
1537 MOZ_ASSERT(mDocument->GetReadyStateEnum() == nsIDocument::READYSTATE_LOADING);
1538 mBlockingDOMContentLoaded = true;
1539 mDocument->BlockDOMContentLoaded();
1540 }
1541 }
1542
1543 bool
1544 nsScriptLoader::MaybeRemovedDeferRequests()
1545 {
1546 if (mDeferRequests.Length() == 0 && mDocument &&
1547 mBlockingDOMContentLoaded) {
1548 mBlockingDOMContentLoaded = false;
1549 mDocument->UnblockDOMContentLoaded();
1550 return true;
1551 }
1552 return false;
1553 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial