?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 1692937 [wpt PR 27636] - new parameter --include-file for wptrunner, a=testonly
[gecko.git] / layout / style / Loader.cpp
blobd7f7b8cfcebae03cadd14b204b6c445a2991375f
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
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 /* loading of CSS style sheets using the network APIs */
8
9 #include "mozilla/css/Loader.h"
10
11 #include "mozilla/ArrayUtils.h"
12 #include "mozilla/dom/DocGroup.h"
13 #include "mozilla/dom/SRILogHelper.h"
14 #include "mozilla/IntegerPrintfMacros.h"
15 #include "mozilla/AutoRestore.h"
16 #include "mozilla/LoadInfo.h"
17 #include "mozilla/Logging.h"
18 #include "mozilla/MemoryReporting.h"
19 #include "mozilla/PreloadHashKey.h"
20 #include "mozilla/ResultExtensions.h"
21 #include "mozilla/SchedulerGroup.h"
22 #include "mozilla/URLPreloader.h"
23 #include "nsIRunnable.h"
24 #include "nsISupportsPriority.h"
25 #include "nsITimedChannel.h"
26 #include "nsICachingChannel.h"
27 #include "nsSyncLoadService.h"
28 #include "nsCOMPtr.h"
29 #include "nsString.h"
30 #include "nsIContent.h"
31 #include "nsIContentInlines.h"
32 #include "nsICookieJarSettings.h"
33 #include "mozilla/dom/Document.h"
34 #include "nsIURI.h"
35 #include "nsNetUtil.h"
36 #include "nsContentUtils.h"
37 #include "nsIScriptSecurityManager.h"
38 #include "nsContentPolicyUtils.h"
39 #include "nsIHttpChannel.h"
40 #include "nsIHttpChannelInternal.h"
41 #include "nsIClassOfService.h"
42 #include "nsIScriptError.h"
43 #include "nsMimeTypes.h"
44 #include "nsICSSLoaderObserver.h"
45 #include "nsThreadUtils.h"
46 #include "nsGkAtoms.h"
47 #include "nsIThreadInternal.h"
48 #include "nsINetworkPredictor.h"
49 #include "nsStringStream.h"
50 #include "mozilla/dom/MediaList.h"
51 #include "mozilla/dom/ShadowRoot.h"
52 #include "mozilla/dom/URL.h"
53 #include "mozilla/net/UrlClassifierFeatureFactory.h"
54 #include "mozilla/AsyncEventDispatcher.h"
55 #include "mozilla/ProfilerLabels.h"
56 #include "mozilla/ServoBindings.h"
57 #include "mozilla/StyleSheet.h"
58 #include "mozilla/StyleSheetInlines.h"
59 #include "mozilla/ConsoleReportCollector.h"
60 #include "mozilla/ServoUtils.h"
61 #include "mozilla/css/StreamLoader.h"
62 #include "mozilla/SharedStyleSheetCache.h"
63 #include "mozilla/StaticPrefs_dom.h"
64 #include "ReferrerInfo.h"
65
66 #ifdef MOZ_XUL
67 # include "nsXULPrototypeCache.h"
68 #endif
69
70 #include "nsError.h"
71
72 #include "mozilla/dom/SRICheck.h"
73
74 #include "mozilla/Encoding.h"
75
76 using namespace mozilla::dom;
77
78 // 1024 bytes is specified in https://drafts.csswg.org/css-syntax/
79 #define SNIFFING_BUFFER_SIZE 1024
80
81 /**
82 * OVERALL ARCHITECTURE
83 *
84 * The CSS Loader gets requests to load various sorts of style sheets:
85 * inline style from <style> elements, linked style, @import-ed child
86 * sheets, non-document sheets. The loader handles the following tasks:
87 * 1) Creation of the actual style sheet objects: CreateSheet()
88 * 2) setting of the right media, title, enabled state, etc on the
89 * sheet: PrepareSheet()
90 * 3) Insertion of the sheet in the proper cascade order:
91 * InsertSheetInTree() and InsertChildSheet()
92 * 4) Load of the sheet: LoadSheet() including security checks
93 * 5) Parsing of the sheet: ParseSheet()
94 * 6) Cleanup: SheetComplete()
95 *
96 * The detailed documentation for these functions is found with the
97 * function implementations.
98 *
99 * The following helper object is used:
100 * SheetLoadData -- a small class that is used to store all the
101 * information needed for the loading of a sheet;
102 * this class handles listening for the stream
103 * loader completion and also handles charset
104 * determination.
105 */
106
107 extern mozilla::LazyLogModule sCssLoaderLog;
108 mozilla::LazyLogModule sCssLoaderLog("nsCSSLoader");
109
110 static mozilla::LazyLogModule gSriPRLog("SRI");
111
112 #define LOG_ERROR(args) MOZ_LOG(sCssLoaderLog, mozilla::LogLevel::Error, args)
113 #define LOG_WARN(args) MOZ_LOG(sCssLoaderLog, mozilla::LogLevel::Warning, args)
114 #define LOG_DEBUG(args) MOZ_LOG(sCssLoaderLog, mozilla::LogLevel::Debug, args)
115 #define LOG(args) LOG_DEBUG(args)
116
117 #define LOG_ERROR_ENABLED() \
118 MOZ_LOG_TEST(sCssLoaderLog, mozilla::LogLevel::Error)
119 #define LOG_WARN_ENABLED() \
120 MOZ_LOG_TEST(sCssLoaderLog, mozilla::LogLevel::Warning)
121 #define LOG_DEBUG_ENABLED() \
122 MOZ_LOG_TEST(sCssLoaderLog, mozilla::LogLevel::Debug)
123 #define LOG_ENABLED() LOG_DEBUG_ENABLED()
124
125 #define LOG_URI(format, uri) \
126 PR_BEGIN_MACRO \
127 NS_ASSERTION(uri, "Logging null uri"); \
128 if (LOG_ENABLED()) { \
129 LOG((format, uri->GetSpecOrDefault().get())); \
130 } \
131 PR_END_MACRO
132
133 // And some convenience strings...
134 static const char* const gStateStrings[] = {"NeedsParser", "Pending", "Loading",
135 "Complete"};
136
137 namespace mozilla {
138
139 SheetLoadDataHashKey::SheetLoadDataHashKey(const css::SheetLoadData& aLoadData)
140 : mURI(aLoadData.mURI),
141 mPrincipal(aLoadData.mTriggeringPrincipal),
142 mLoaderPrincipal(aLoadData.mLoader->LoaderPrincipal()),
143 mPartitionPrincipal(aLoadData.mLoader->PartitionedPrincipal()),
144 mEncodingGuess(aLoadData.mGuessedEncoding),
145 mCORSMode(aLoadData.mSheet->GetCORSMode()),
146 mParsingMode(aLoadData.mSheet->ParsingMode()),
147 mCompatMode(aLoadData.mCompatMode),
148 mIsLinkRelPreload(aLoadData.IsLinkRelPreload()) {
149 MOZ_COUNT_CTOR(SheetLoadDataHashKey);
150 MOZ_ASSERT(mURI);
151 MOZ_ASSERT(mPrincipal);
152 MOZ_ASSERT(mLoaderPrincipal);
153 MOZ_ASSERT(mPartitionPrincipal);
154 aLoadData.mSheet->GetIntegrity(mSRIMetadata);
155 }
156
157 bool SheetLoadDataHashKey::KeyEquals(const SheetLoadDataHashKey& aKey) const {
158 {
159 bool eq;
160 if (NS_FAILED(mURI->Equals(aKey.mURI, &eq)) || !eq) {
161 return false;
162 }
163 }
164
165 LOG_URI("KeyEquals(%s)\n", mURI);
166
167 if (!mPrincipal->Equals(aKey.mPrincipal)) {
168 LOG((" > Principal mismatch\n"));
169 return false;
170 }
171
172 // We only check for partition principal equality if any of the loads are
173 // triggered by a document rather than e.g. an extension (which have different
174 // origins than the loader principal).
175 if (mPrincipal->Equals(mLoaderPrincipal) ||
176 aKey.mPrincipal->Equals(aKey.mLoaderPrincipal)) {
177 if (!mPartitionPrincipal->Equals(aKey.mPartitionPrincipal)) {
178 LOG((" > Partition principal mismatch\n"));
179 return false;
180 }
181 }
182
183 if (mCORSMode != aKey.mCORSMode) {
184 LOG((" > CORS mismatch\n"));
185 return false;
186 }
187
188 if (mParsingMode != aKey.mParsingMode) {
189 LOG((" > Parsing mode mismatch\n"));
190 return false;
191 }
192
193 if (mCompatMode != aKey.mCompatMode) {
194 LOG((" > Quirks mismatch\n"));
195 return false;
196 }
197
198 // If encoding differs, then don't reuse the cache.
199 //
200 // TODO(emilio): When the encoding is determined from the request (either
201 // BOM or Content-Length or @charset), we could do a bit better,
202 // theoretically.
203 if (mEncodingGuess != aKey.mEncodingGuess) {
204 LOG((" > Encoding guess mismatch\n"));
205 return false;
206 }
207
208 // Consuming stylesheet tags must never coalesce to <link preload> initiated
209 // speculative loads with a weaker SRI hash or its different value. This
210 // check makes sure that regular loads will never find such a weaker preload
211 // and rather start a new, independent load with new, stronger SRI checker
212 // set up, so that integrity is ensured.
213 if (mIsLinkRelPreload != aKey.mIsLinkRelPreload) {
214 const auto& linkPreloadMetadata =
215 mIsLinkRelPreload ? mSRIMetadata : aKey.mSRIMetadata;
216 const auto& consumerPreloadMetadata =
217 mIsLinkRelPreload ? aKey.mSRIMetadata : mSRIMetadata;
218
219 if (!consumerPreloadMetadata.CanTrustBeDelegatedTo(linkPreloadMetadata)) {
220 LOG((" > Preload SRI metadata mismatch\n"));
221 return false;
222 }
223 }
224
225 return true;
226 }
227
228 namespace css {
229
230 static NotNull<const Encoding*> GetFallbackEncoding(
231 Loader& aLoader, nsINode* aOwningNode,
232 const Encoding* aPreloadOrParentDataEncoding) {
233 const Encoding* encoding;
234 // Now try the charset on the <link> or processing instruction
235 // that loaded us
236 if (aOwningNode) {
237 nsAutoString label16;
238 LinkStyle::FromNode(*aOwningNode)->GetCharset(label16);
239 encoding = Encoding::ForLabel(label16);
240 if (encoding) {
241 return WrapNotNull(encoding);
242 }
243 }
244
245 // Try preload or parent sheet encoding.
246 if (aPreloadOrParentDataEncoding) {
247 return WrapNotNull(aPreloadOrParentDataEncoding);
248 }
249
250 if (auto* doc = aLoader.GetDocument()) {
251 // Use the document charset.
252 return doc->GetDocumentCharacterSet();
253 }
254
255 return UTF_8_ENCODING;
256 }
257
258 /********************************
259 * SheetLoadData implementation *
260 ********************************/
261 NS_IMPL_ISUPPORTS(SheetLoadData, nsIRunnable, nsIThreadObserver)
262
263 SheetLoadData::SheetLoadData(
264 Loader* aLoader, const nsAString& aTitle, nsIURI* aURI, StyleSheet* aSheet,
265 bool aSyncLoad, nsINode* aOwningNode, IsAlternate aIsAlternate,
266 MediaMatched aMediaMatches, StylePreloadKind aPreloadKind,
267 nsICSSLoaderObserver* aObserver, nsIPrincipal* aTriggeringPrincipal,
268 nsIReferrerInfo* aReferrerInfo, nsINode* aRequestingNode)
269 : mLoader(aLoader),
270 mTitle(aTitle),
271 mEncoding(nullptr),
272 mURI(aURI),
273 mLineNumber(1),
274 mSheet(aSheet),
275 mNext(nullptr),
276 mPendingChildren(0),
277 mSyncLoad(aSyncLoad),
278 mIsNonDocumentSheet(false),
279 mIsChildSheet(aSheet->GetParentSheet()),
280 mIsLoading(false),
281 mIsBeingParsed(false),
282 mIsCancelled(false),
283 mMustNotify(false),
284 mWasAlternate(aIsAlternate == IsAlternate::Yes),
285 mMediaMatched(aMediaMatches == MediaMatched::Yes),
286 mUseSystemPrincipal(false),
287 mSheetAlreadyComplete(false),
288 mIsCrossOriginNoCORS(false),
289 mBlockResourceTiming(false),
290 mLoadFailed(false),
291 mPreloadKind(aPreloadKind),
292 mOwningNode(aOwningNode),
293 mObserver(aObserver),
294 mTriggeringPrincipal(aTriggeringPrincipal),
295 mReferrerInfo(aReferrerInfo),
296 mRequestingNode(aRequestingNode),
297 mGuessedEncoding(GetFallbackEncoding(*aLoader, aOwningNode, nullptr)),
298 mCompatMode(aLoader->CompatMode(aPreloadKind)) {
299 MOZ_ASSERT(!mOwningNode || dom::LinkStyle::FromNode(*mOwningNode),
300 "Must implement LinkStyle");
301 MOZ_ASSERT(mTriggeringPrincipal);
302 MOZ_ASSERT(mLoader, "Must have a loader!");
303 }
304
305 SheetLoadData::SheetLoadData(Loader* aLoader, nsIURI* aURI, StyleSheet* aSheet,
306 SheetLoadData* aParentData,
307 nsICSSLoaderObserver* aObserver,
308 nsIPrincipal* aTriggeringPrincipal,
309 nsIReferrerInfo* aReferrerInfo,
310 nsINode* aRequestingNode)
311 : mLoader(aLoader),
312 mEncoding(nullptr),
313 mURI(aURI),
314 mLineNumber(1),
315 mSheet(aSheet),
316 mNext(nullptr),
317 mParentData(aParentData),
318 mPendingChildren(0),
319 mSyncLoad(aParentData && aParentData->mSyncLoad),
320 mIsNonDocumentSheet(aParentData && aParentData->mIsNonDocumentSheet),
321 mIsChildSheet(aSheet->GetParentSheet()),
322 mIsLoading(false),
323 mIsBeingParsed(false),
324 mIsCancelled(false),
325 mMustNotify(false),
326 mWasAlternate(false),
327 mMediaMatched(true),
328 mUseSystemPrincipal(aParentData && aParentData->mUseSystemPrincipal),
329 mSheetAlreadyComplete(false),
330 mIsCrossOriginNoCORS(false),
331 mBlockResourceTiming(false),
332 mLoadFailed(false),
333 mPreloadKind(StylePreloadKind::None),
334 mOwningNode(nullptr),
335 mObserver(aObserver),
336 mTriggeringPrincipal(aTriggeringPrincipal),
337 mReferrerInfo(aReferrerInfo),
338 mRequestingNode(aRequestingNode),
339 mGuessedEncoding(GetFallbackEncoding(
340 *aLoader, nullptr, aParentData ? aParentData->mEncoding : nullptr)),
341 mCompatMode(aLoader->CompatMode(mPreloadKind)) {
342 MOZ_ASSERT(mLoader, "Must have a loader!");
343 MOZ_ASSERT(mTriggeringPrincipal);
344 MOZ_ASSERT(!mUseSystemPrincipal || mSyncLoad,
345 "Shouldn't use system principal for async loads");
346 MOZ_ASSERT_IF(aParentData, mIsChildSheet);
347 }
348
349 SheetLoadData::SheetLoadData(
350 Loader* aLoader, nsIURI* aURI, StyleSheet* aSheet, bool aSyncLoad,
351 UseSystemPrincipal aUseSystemPrincipal, StylePreloadKind aPreloadKind,
352 const Encoding* aPreloadEncoding, nsICSSLoaderObserver* aObserver,
353 nsIPrincipal* aTriggeringPrincipal, nsIReferrerInfo* aReferrerInfo,
354 nsINode* aRequestingNode)
355 : mLoader(aLoader),
356 mEncoding(nullptr),
357 mURI(aURI),
358 mLineNumber(1),
359 mSheet(aSheet),
360 mNext(nullptr),
361 mPendingChildren(0),
362 mSyncLoad(aSyncLoad),
363 mIsNonDocumentSheet(true),
364 mIsChildSheet(false),
365 mIsLoading(false),
366 mIsBeingParsed(false),
367 mIsCancelled(false),
368 mMustNotify(false),
369 mWasAlternate(false),
370 mMediaMatched(true),
371 mUseSystemPrincipal(aUseSystemPrincipal == UseSystemPrincipal::Yes),
372 mSheetAlreadyComplete(false),
373 mIsCrossOriginNoCORS(false),
374 mBlockResourceTiming(false),
375 mLoadFailed(false),
376 mPreloadKind(aPreloadKind),
377 mOwningNode(nullptr),
378 mObserver(aObserver),
379 mTriggeringPrincipal(aTriggeringPrincipal),
380 mReferrerInfo(aReferrerInfo),
381 mRequestingNode(aRequestingNode),
382 mGuessedEncoding(
383 GetFallbackEncoding(*aLoader, nullptr, aPreloadEncoding)),
384 mCompatMode(aLoader->CompatMode(aPreloadKind)) {
385 MOZ_ASSERT(mTriggeringPrincipal);
386 MOZ_ASSERT(mLoader, "Must have a loader!");
387 MOZ_ASSERT(!mUseSystemPrincipal || mSyncLoad,
388 "Shouldn't use system principal for async loads");
389 MOZ_ASSERT(!aSheet->GetParentSheet(), "Shouldn't be used for child loads");
390 }
391
392 SheetLoadData::~SheetLoadData() {
393 MOZ_DIAGNOSTIC_ASSERT(mSheetCompleteCalled || mIntentionallyDropped,
394 "Should always call SheetComplete, except when "
395 "dropping the load");
396
397 // Do this iteratively to avoid blowing up the stack.
398 RefPtr<SheetLoadData> next = std::move(mNext);
399 while (next) {
400 next = std::move(next->mNext);
401 }
402 }
403
404 NS_IMETHODIMP
405 SheetLoadData::Run() {
406 mLoader->HandleLoadEvent(*this);
407 return NS_OK;
408 }
409
410 NS_IMETHODIMP
411 SheetLoadData::OnDispatchedEvent() { return NS_OK; }
412
413 NS_IMETHODIMP
414 SheetLoadData::OnProcessNextEvent(nsIThreadInternal* aThread, bool aMayWait) {
415 // XXXkhuey this is insane!
416 // We want to fire our load even before or after event processing,
417 // whichever comes first.
418 FireLoadEvent(aThread);
419 return NS_OK;
420 }
421
422 NS_IMETHODIMP
423 SheetLoadData::AfterProcessNextEvent(nsIThreadInternal* aThread,
424 bool aEventWasProcessed) {
425 // XXXkhuey this too!
426 // We want to fire our load even before or after event processing,
427 // whichever comes first.
428 FireLoadEvent(aThread);
429 return NS_OK;
430 }
431
432 void SheetLoadData::PrioritizeAsPreload(nsIChannel* aChannel) {
433 if (nsCOMPtr<nsISupportsPriority> sp = do_QueryInterface(aChannel)) {
434 sp->AdjustPriority(nsISupportsPriority::PRIORITY_HIGHEST);
435 }
436 }
437
438 void SheetLoadData::PrioritizeAsPreload() { PrioritizeAsPreload(Channel()); }
439
440 void SheetLoadData::FireLoadEvent(nsIThreadInternal* aThread) {
441 // First remove ourselves as a thread observer. But we need to keep
442 // ourselves alive while doing that!
443 RefPtr<SheetLoadData> kungFuDeathGrip(this);
444 aThread->RemoveObserver(this);
445
446 // Now fire the event.
447 //
448 // NOTE(emilio): A bit weird that we fire the event even if the node is no
449 // longer in the tree, or the sheet that just loaded / errored is not the
450 // current node.sheet, but...
451 nsCOMPtr<nsINode> node = mOwningNode;
452 MOZ_ASSERT(node, "How did that happen???");
453
454 nsContentUtils::DispatchTrustedEvent(node->OwnerDoc(), node,
455 mLoadFailed ? u"error"_ns : u"load"_ns,
456 CanBubble::eNo, Cancelable::eNo);
457
458 MOZ_ASSERT(BlocksLoadEvent());
459 mLoader->UnblockOnload(true);
460 }
461
462 void SheetLoadData::ScheduleLoadEventIfNeeded() {
463 if (!mOwningNode) {
464 return;
465 }
466
467 MOZ_ASSERT(BlocksLoadEvent(), "The rel=preload load event happens elsewhere");
468
469 nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
470 nsCOMPtr<nsIThreadInternal> internalThread = do_QueryInterface(thread);
471 if (NS_SUCCEEDED(internalThread->AddObserver(this))) {
472 mLoader->BlockOnload();
473 }
474 }
475
476 /*********************
477 * Style sheet reuse *
478 *********************/
479
480 bool LoaderReusableStyleSheets::FindReusableStyleSheet(
481 nsIURI* aURL, RefPtr<StyleSheet>& aResult) {
482 MOZ_ASSERT(aURL);
483 for (size_t i = mReusableSheets.Length(); i > 0; --i) {
484 size_t index = i - 1;
485 bool sameURI;
486 MOZ_ASSERT(mReusableSheets[index]->GetOriginalURI());
487 nsresult rv =
488 aURL->Equals(mReusableSheets[index]->GetOriginalURI(), &sameURI);
489 if (!NS_FAILED(rv) && sameURI) {
490 aResult = mReusableSheets[index];
491 mReusableSheets.RemoveElementAt(index);
492 return true;
493 }
494 }
495 return false;
496 }
497 /*************************
498 * Loader Implementation *
499 *************************/
500
501 Loader::Loader()
502 : mDocument(nullptr),
503 mDocumentCompatMode(eCompatibility_FullStandards),
504 mReporter(new ConsoleReportCollector()) {}
505
506 Loader::Loader(DocGroup* aDocGroup) : Loader() { mDocGroup = aDocGroup; }
507
508 Loader::Loader(Document* aDocument) : Loader() {
509 MOZ_ASSERT(aDocument, "We should get a valid document from the caller!");
510 mDocument = aDocument;
511 mDocumentCompatMode = aDocument->GetCompatibilityMode();
512 mSheets = SharedStyleSheetCache::Get();
513 RegisterInSheetCache();
514 }
515
516 Loader::~Loader() {
517 // Note: no real need to revoke our stylesheet loaded events -- they
518 // hold strong references to us, so if we're going away that means
519 // they're all done.
520 }
521
522 void Loader::RegisterInSheetCache() {
523 MOZ_ASSERT(mDocument);
524 MOZ_ASSERT(mSheets);
525
526 mSheets->RegisterLoader(*this);
527 }
528
529 void Loader::DeregisterFromSheetCache() {
530 MOZ_ASSERT(mDocument);
531 MOZ_ASSERT(mSheets);
532
533 mSheets->CancelLoadsForLoader(*this);
534 mSheets->UnregisterLoader(*this);
535 }
536
537 void Loader::DropDocumentReference() {
538 // Flush out pending datas just so we don't leak by accident.
539 if (mSheets) {
540 DeregisterFromSheetCache();
541 }
542 mDocument = nullptr;
543 }
544
545 void Loader::DocumentStyleSheetSetChanged() {
546 MOZ_ASSERT(mDocument);
547
548 // start any pending alternates that aren't alternates anymore
549 mSheets->StartDeferredLoadsForLoader(
550 *this, SharedStyleSheetCache::StartLoads::IfNonAlternate);
551 }
552
553 static const char kCharsetSym[] = "@charset \"";
554
555 static bool GetCharsetFromData(const char* aStyleSheetData,
556 uint32_t aDataLength, nsACString& aCharset) {
557 aCharset.Truncate();
558 if (aDataLength <= sizeof(kCharsetSym) - 1) return false;
559
560 if (strncmp(aStyleSheetData, kCharsetSym, sizeof(kCharsetSym) - 1)) {
561 return false;
562 }
563
564 for (uint32_t i = sizeof(kCharsetSym) - 1; i < aDataLength; ++i) {
565 char c = aStyleSheetData[i];
566 if (c == '"') {
567 ++i;
568 if (i < aDataLength && aStyleSheetData[i] == ';') {
569 return true;
570 }
571 // fail
572 break;
573 }
574 aCharset.Append(c);
575 }
576
577 // Did not see end quote or semicolon
578 aCharset.Truncate();
579 return false;
580 }
581
582 NotNull<const Encoding*> SheetLoadData::DetermineNonBOMEncoding(
583 const nsACString& aSegment, nsIChannel* aChannel) const {
584 const Encoding* encoding;
585 nsAutoCString label;
586
587 // Check HTTP
588 if (aChannel && NS_SUCCEEDED(aChannel->GetContentCharset(label))) {
589 encoding = Encoding::ForLabel(label);
590 if (encoding) {
591 return WrapNotNull(encoding);
592 }
593 }
594
595 // Check @charset
596 auto sniffingLength = aSegment.Length();
597 if (sniffingLength > SNIFFING_BUFFER_SIZE) {
598 sniffingLength = SNIFFING_BUFFER_SIZE;
599 }
600 if (GetCharsetFromData(aSegment.BeginReading(), sniffingLength, label)) {
601 encoding = Encoding::ForLabel(label);
602 if (encoding == UTF_16BE_ENCODING || encoding == UTF_16LE_ENCODING) {
603 return UTF_8_ENCODING;
604 }
605 if (encoding) {
606 return WrapNotNull(encoding);
607 }
608 }
609 return mGuessedEncoding;
610 }
611
612 static nsresult VerifySheetIntegrity(const SRIMetadata& aMetadata,
613 nsIChannel* aChannel,
614 const nsACString& aFirst,
615 const nsACString& aSecond,
616 const nsACString& aSourceFileURI,
617 nsIConsoleReportCollector* aReporter) {
618 NS_ENSURE_ARG_POINTER(aReporter);
619
620 if (MOZ_LOG_TEST(SRILogHelper::GetSriLog(), LogLevel::Debug)) {
621 nsAutoCString requestURL;
622 nsCOMPtr<nsIURI> originalURI;
623 if (aChannel &&
624 NS_SUCCEEDED(aChannel->GetOriginalURI(getter_AddRefs(originalURI))) &&
625 originalURI) {
626 originalURI->GetAsciiSpec(requestURL);
627 }
628 MOZ_LOG(SRILogHelper::GetSriLog(), LogLevel::Debug,
629 ("VerifySheetIntegrity (unichar stream)"));
630 }
631
632 SRICheckDataVerifier verifier(aMetadata, aSourceFileURI, aReporter);
633 nsresult rv =
634 verifier.Update(aFirst.Length(), (const uint8_t*)aFirst.BeginReading());
635 NS_ENSURE_SUCCESS(rv, rv);
636 rv =
637 verifier.Update(aSecond.Length(), (const uint8_t*)aSecond.BeginReading());
638 NS_ENSURE_SUCCESS(rv, rv);
639
640 return verifier.Verify(aMetadata, aChannel, aSourceFileURI, aReporter);
641 }
642
643 static bool AllLoadsCanceled(const SheetLoadData& aData) {
644 const SheetLoadData* data = &aData;
645 do {
646 if (!data->mIsCancelled) {
647 return false;
648 }
649 } while ((data = data->mNext));
650 return true;
651 }
652
653 /*
654 * Stream completion code shared by Stylo and the old style system.
655 *
656 * Here we need to check that the load did not give us an http error
657 * page and check the mimetype on the channel to make sure we're not
658 * loading non-text/css data in standards mode.
659 */
660 nsresult SheetLoadData::VerifySheetReadyToParse(nsresult aStatus,
661 const nsACString& aBytes1,
662 const nsACString& aBytes2,
663 nsIChannel* aChannel) {
664 LOG(("SheetLoadData::VerifySheetReadyToParse"));
665 NS_ASSERTION(!mLoader->mSyncCallback, "Synchronous callback from necko");
666
667 if (AllLoadsCanceled(*this)) {
668 LOG_WARN((" All loads are canceled, dropping"));
669 mLoader->SheetComplete(*this, NS_BINDING_ABORTED);
670 return NS_OK;
671 }
672
673 if (NS_FAILED(aStatus)) {
674 LOG_WARN(
675 (" Load failed: status 0x%" PRIx32, static_cast<uint32_t>(aStatus)));
676 // Handle sheet not loading error because source was a tracking URL (or
677 // fingerprinting, cryptomining, etc).
678 // We make a note of this sheet node by including it in a dedicated
679 // array of blocked tracking nodes under its parent document.
680 //
681 // Multiple sheet load instances might be tied to this request,
682 // we annotate each one linked to a valid owning element (node).
683 if (net::UrlClassifierFeatureFactory::IsClassifierBlockingErrorCode(
684 aStatus)) {
685 if (Document* doc = mLoader->GetDocument()) {
686 for (SheetLoadData* data = this; data; data = data->mNext) {
687 // mOwningNode may be null but AddBlockTrackingNode can cope
688 doc->AddBlockedNodeByClassifier(
689 nsIContent::FromNodeOrNull(data->mOwningNode));
690 }
691 }
692 }
693 mLoader->SheetComplete(*this, aStatus);
694 return NS_OK;
695 }
696
697 if (!aChannel) {
698 mLoader->SheetComplete(*this, NS_OK);
699 return NS_OK;
700 }
701
702 nsCOMPtr<nsIURI> originalURI;
703 aChannel->GetOriginalURI(getter_AddRefs(originalURI));
704
705 // If the channel's original URI is "chrome:", we want that, since
706 // the observer code in nsXULPrototypeCache depends on chrome stylesheets
707 // having a chrome URI. (Whether or not chrome stylesheets come through
708 // this codepath seems nondeterministic.)
709 // Otherwise we want the potentially-HTTP-redirected URI.
710 nsCOMPtr<nsIURI> channelURI;
711 NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI));
712
713 if (!channelURI || !originalURI) {
714 NS_ERROR("Someone just violated the nsIRequest contract");
715 LOG_WARN((" Channel without a URI. Bad!"));
716 mLoader->SheetComplete(*this, NS_ERROR_UNEXPECTED);
717 return NS_OK;
718 }
719
720 nsCOMPtr<nsIPrincipal> principal;
721 nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
722 nsresult result = NS_ERROR_NOT_AVAILABLE;
723 if (secMan) { // Could be null if we already shut down
724 if (mUseSystemPrincipal) {
725 result = secMan->GetSystemPrincipal(getter_AddRefs(principal));
726 } else {
727 result = secMan->GetChannelResultPrincipal(aChannel,
728 getter_AddRefs(principal));
729 }
730 }
731
732 if (NS_FAILED(result)) {
733 LOG_WARN((" Couldn't get principal"));
734 mLoader->SheetComplete(*this, result);
735 return NS_OK;
736 }
737
738 mSheet->SetPrincipal(principal);
739
740 if (mSheet->GetCORSMode() == CORS_NONE &&
741 !mTriggeringPrincipal->Subsumes(principal)) {
742 mIsCrossOriginNoCORS = true;
743 }
744
745 // If it's an HTTP channel, we want to make sure this is not an
746 // error document we got.
747 if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel)) {
748 bool requestSucceeded;
749 result = httpChannel->GetRequestSucceeded(&requestSucceeded);
750 if (NS_SUCCEEDED(result) && !requestSucceeded) {
751 LOG((" Load returned an error page"));
752 mLoader->SheetComplete(*this, NS_ERROR_NOT_AVAILABLE);
753 return NS_OK;
754 }
755
756 nsAutoCString sourceMapURL;
757 if (nsContentUtils::GetSourceMapURL(httpChannel, sourceMapURL)) {
758 mSheet->SetSourceMapURL(NS_ConvertUTF8toUTF16(sourceMapURL));
759 }
760 }
761
762 nsAutoCString contentType;
763 aChannel->GetContentType(contentType);
764
765 // In standards mode, a style sheet must have one of these MIME
766 // types to be processed at all. In quirks mode, we accept any
767 // MIME type, but only if the style sheet is same-origin with the
768 // requesting document or parent sheet. See bug 524223.
769
770 bool validType = contentType.EqualsLiteral("text/css") ||
771 contentType.EqualsLiteral(UNKNOWN_CONTENT_TYPE) ||
772 contentType.IsEmpty();
773
774 if (!validType) {
775 const char* errorMessage;
776 uint32_t errorFlag;
777 bool sameOrigin = true;
778
779 bool subsumed;
780 result = mTriggeringPrincipal->Subsumes(principal, &subsumed);
781 if (NS_FAILED(result) || !subsumed) {
782 sameOrigin = false;
783 }
784
785 if (sameOrigin && mCompatMode == eCompatibility_NavQuirks) {
786 errorMessage = "MimeNotCssWarn";
787 errorFlag = nsIScriptError::warningFlag;
788 } else {
789 errorMessage = "MimeNotCss";
790 errorFlag = nsIScriptError::errorFlag;
791 }
792
793 AutoTArray<nsString, 2> strings;
794 CopyUTF8toUTF16(channelURI->GetSpecOrDefault(), *strings.AppendElement());
795 CopyASCIItoUTF16(contentType, *strings.AppendElement());
796
797 nsCOMPtr<nsIURI> referrer = ReferrerInfo()->GetOriginalReferrer();
798 nsContentUtils::ReportToConsole(
799 errorFlag, "CSS Loader"_ns, mLoader->mDocument,
800 nsContentUtils::eCSS_PROPERTIES, errorMessage, strings, referrer);
801
802 if (errorFlag == nsIScriptError::errorFlag) {
803 LOG_WARN(
804 (" Ignoring sheet with improper MIME type %s", contentType.get()));
805 mLoader->SheetComplete(*this, NS_ERROR_NOT_AVAILABLE);
806 return NS_OK;
807 }
808 }
809
810 SRIMetadata sriMetadata;
811 mSheet->GetIntegrity(sriMetadata);
812 if (!sriMetadata.IsEmpty()) {
813 nsAutoCString sourceUri;
814 if (mLoader->mDocument && mLoader->mDocument->GetDocumentURI()) {
815 mLoader->mDocument->GetDocumentURI()->GetAsciiSpec(sourceUri);
816 }
817 nsresult rv = VerifySheetIntegrity(sriMetadata, aChannel, aBytes1, aBytes2,
818 sourceUri, mLoader->mReporter);
819
820 nsCOMPtr<nsILoadGroup> loadGroup;
821 aChannel->GetLoadGroup(getter_AddRefs(loadGroup));
822 if (loadGroup) {
823 mLoader->mReporter->FlushConsoleReports(loadGroup);
824 } else {
825 mLoader->mReporter->FlushConsoleReports(mLoader->mDocument);
826 }
827
828 if (NS_FAILED(rv)) {
829 LOG((" Load was blocked by SRI"));
830 MOZ_LOG(gSriPRLog, LogLevel::Debug,
831 ("css::Loader::OnStreamComplete, bad metadata"));
832 mLoader->SheetComplete(*this, NS_ERROR_SRI_CORRUPT);
833 return NS_OK;
834 }
835 }
836
837 // Enough to set the URIs on mSheet, since any sibling datas we have share
838 // the same mInner as mSheet and will thus get the same URI.
839 mSheet->SetURIs(channelURI, originalURI, channelURI);
840
841 ReferrerPolicy policy =
842 nsContentUtils::GetReferrerPolicyFromChannel(aChannel);
843 nsCOMPtr<nsIReferrerInfo> referrerInfo =
844 ReferrerInfo::CreateForExternalCSSResources(mSheet, policy);
845
846 mSheet->SetReferrerInfo(referrerInfo);
847 return NS_OK_PARSE_SHEET;
848 }
849
850 Loader::IsAlternate Loader::IsAlternateSheet(const nsAString& aTitle,
851 bool aHasAlternateRel) {
852 // A sheet is alternate if it has a nonempty title that doesn't match the
853 // currently selected style set. But if there _is_ no currently selected
854 // style set, the sheet wasn't marked as an alternate explicitly, and aTitle
855 // is nonempty, we should select the style set corresponding to aTitle, since
856 // that's a preferred sheet.
857 if (aTitle.IsEmpty()) {
858 return IsAlternate::No;
859 }
860
861 if (mDocument) {
862 const nsString& currentSheetSet = mDocument->GetCurrentStyleSheetSet();
863 if (!aHasAlternateRel && currentSheetSet.IsEmpty()) {
864 // There's no preferred set yet, and we now have a sheet with a title.
865 // Make that be the preferred set.
866 // FIXME(emilio): This is kinda wild, can we do it somewhere else?
867 mDocument->SetPreferredStyleSheetSet(aTitle);
868 // We're definitely not an alternate. Also, beware that at this point
869 // currentSheetSet may dangle.
870 return IsAlternate::No;
871 }
872
873 if (aTitle.Equals(currentSheetSet)) {
874 return IsAlternate::No;
875 }
876 }
877
878 return IsAlternate::Yes;
879 }
880
881 nsresult Loader::CheckContentPolicy(nsIPrincipal* aLoadingPrincipal,
882 nsIPrincipal* aTriggeringPrincipal,
883 nsIURI* aTargetURI,
884 nsINode* aRequestingNode,
885 const nsAString& aNonce,
886 StylePreloadKind aPreloadKind) {
887 // When performing a system load don't consult content policies.
888 if (!mDocument) {
889 return NS_OK;
890 }
891
892 nsContentPolicyType contentPolicyType =
893 aPreloadKind == StylePreloadKind::None
894 ? nsIContentPolicy::TYPE_INTERNAL_STYLESHEET
895 : nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD;
896
897 nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
898 aLoadingPrincipal, aTriggeringPrincipal, aRequestingNode,
899 nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, contentPolicyType);
900
901 // snapshot the nonce at load start time for performing CSP checks
902 if (contentPolicyType == nsIContentPolicy::TYPE_INTERNAL_STYLESHEET) {
903 secCheckLoadInfo->SetCspNonce(aNonce);
904 MOZ_ASSERT_IF(aPreloadKind != StylePreloadKind::None, aNonce.IsEmpty());
905 }
906
907 int16_t shouldLoad = nsIContentPolicy::ACCEPT;
908 nsresult rv = NS_CheckContentLoadPolicy(aTargetURI, secCheckLoadInfo,
909 "text/css"_ns, &shouldLoad,
910 nsContentUtils::GetContentPolicy());
911 if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
912 return NS_ERROR_CONTENT_BLOCKED;
913 }
914 return NS_OK;
915 }
916
917 static void RecordUseCountersIfNeeded(Document* aDoc,
918 const StyleUseCounters* aCounters) {
919 if (!aDoc || !aCounters) {
920 return;
921 }
922 const StyleUseCounters* docCounters = aDoc->GetStyleUseCounters();
923 if (!docCounters) {
924 return;
925 }
926 Servo_UseCounters_Merge(docCounters, aCounters);
927 aDoc->MaybeWarnAboutZoom();
928 }
929
930 void Loader::DidHitCompleteSheetCache(const SheetLoadDataHashKey& aKey,
931 const StyleUseCounters* aCounters) {
932 MOZ_ASSERT(mDocument);
933 if (mLoadsPerformed.EnsureInserted(aKey)) {
934 RecordUseCountersIfNeeded(mDocument, aCounters);
935 }
936 }
937
938 /**
939 * CreateSheet() creates a StyleSheet object for the given URI.
940 *
941 * We check for an existing style sheet object for that uri in various caches
942 * and clone it if we find it. Cloned sheets will have the title/media/enabled
943 * state of the sheet they are clones off; make sure to call PrepareSheet() on
944 * the result of CreateSheet().
945 */
946 std::tuple<RefPtr<StyleSheet>, Loader::SheetState> Loader::CreateSheet(
947 nsIURI* aURI, nsIContent* aLinkingContent,
948 nsIPrincipal* aTriggeringPrincipal, css::SheetParsingMode aParsingMode,
949 CORSMode aCORSMode, const Encoding* aPreloadOrParentDataEncoding,
950 const nsAString& aIntegrity, bool aSyncLoad,
951 StylePreloadKind aPreloadKind) {
952 MOZ_ASSERT(aURI, "This path is not taken for inline stylesheets");
953 LOG(("css::Loader::CreateSheet(%s)", aURI->GetSpecOrDefault().get()));
954
955 SRIMetadata sriMetadata;
956 if (!aIntegrity.IsEmpty()) {
957 MOZ_LOG(gSriPRLog, LogLevel::Debug,
958 ("css::Loader::CreateSheet, integrity=%s",
959 NS_ConvertUTF16toUTF8(aIntegrity).get()));
960 nsAutoCString sourceUri;
961 if (mDocument && mDocument->GetDocumentURI()) {
962 mDocument->GetDocumentURI()->GetAsciiSpec(sourceUri);
963 }
964 SRICheck::IntegrityMetadata(aIntegrity, sourceUri, mReporter, &sriMetadata);
965 }
966
967 if (mSheets) {
968 SheetLoadDataHashKey key(aURI, aTriggeringPrincipal, LoaderPrincipal(),
969 PartitionedPrincipal(),
970 GetFallbackEncoding(*this, aLinkingContent,
971 aPreloadOrParentDataEncoding),
972 aCORSMode, aParsingMode, CompatMode(aPreloadKind),
973 sriMetadata, aPreloadKind);
974 auto cacheResult = mSheets->Lookup(*this, key, aSyncLoad);
975 if (const auto& [styleSheet, sheetState] = cacheResult; styleSheet) {
976 LOG((" Hit cache with state: %s", gStateStrings[size_t(sheetState)]));
977 return cacheResult;
978 }
979 }
980
981 nsIURI* sheetURI = aURI;
982 nsIURI* baseURI = aURI;
983 nsIURI* originalURI = aURI;
984
985 auto sheet = MakeRefPtr<StyleSheet>(aParsingMode, aCORSMode, sriMetadata);
986 sheet->SetURIs(sheetURI, originalURI, baseURI);
987 nsCOMPtr<nsIReferrerInfo> referrerInfo =
988 ReferrerInfo::CreateForExternalCSSResources(sheet);
989 sheet->SetReferrerInfo(referrerInfo);
990 LOG((" Needs parser"));
991 return {std::move(sheet), SheetState::NeedsParser};
992 }
993
994 static Loader::MediaMatched MediaListMatches(const MediaList* aMediaList,
995 const Document* aDocument) {
996 if (!aMediaList || !aDocument) {
997 return Loader::MediaMatched::Yes;
998 }
999
1000 if (aMediaList->Matches(*aDocument)) {
1001 return Loader::MediaMatched::Yes;
1002 }
1003
1004 return Loader::MediaMatched::No;
1005 }
1006
1007 /**
1008 * PrepareSheet() handles setting the media and title on the sheet, as
1009 * well as setting the enabled state based on the title and whether
1010 * the sheet had "alternate" in its rel.
1011 */
1012 Loader::MediaMatched Loader::PrepareSheet(
1013 StyleSheet& aSheet, const nsAString& aTitle, const nsAString& aMediaString,
1014 MediaList* aMediaList, IsAlternate aIsAlternate,
1015 IsExplicitlyEnabled aIsExplicitlyEnabled) {
1016 RefPtr<MediaList> mediaList(aMediaList);
1017
1018 if (!aMediaString.IsEmpty()) {
1019 NS_ASSERTION(!aMediaList,
1020 "must not provide both aMediaString and aMediaList");
1021 mediaList = MediaList::Create(NS_ConvertUTF16toUTF8(aMediaString));
1022 }
1023
1024 aSheet.SetMedia(do_AddRef(mediaList));
1025
1026 aSheet.SetTitle(aTitle);
1027 aSheet.SetEnabled(aIsAlternate == IsAlternate::No ||
1028 aIsExplicitlyEnabled == IsExplicitlyEnabled::Yes);
1029 return MediaListMatches(mediaList, mDocument);
1030 }
1031
1032 /**
1033 * InsertSheetInTree handles ordering of sheets in the document or shadow root.
1034 *
1035 * Here we have two types of sheets -- those with linking elements and
1036 * those without. The latter are loaded by Link: headers, and are only added to
1037 * the document.
1038 *
1039 * The following constraints are observed:
1040 * 1) Any sheet with a linking element comes after all sheets without
1041 * linking elements
1042 * 2) Sheets without linking elements are inserted in the order in
1043 * which the inserting requests come in, since all of these are
1044 * inserted during header data processing in the content sink
1045 * 3) Sheets with linking elements are ordered based on document order
1046 * as determined by CompareDocumentPosition.
1047 */
1048 void Loader::InsertSheetInTree(StyleSheet& aSheet, nsINode* aOwningNode) {
1049 LOG(("css::Loader::InsertSheetInTree"));
1050 MOZ_ASSERT(mDocument, "Must have a document to insert into");
1051 MOZ_ASSERT(!aOwningNode || aOwningNode->IsInUncomposedDoc() ||
1052 aOwningNode->IsInShadowTree(),
1053 "Why would we insert it anywhere?");
1054 ShadowRoot* shadow =
1055 aOwningNode ? aOwningNode->GetContainingShadow() : nullptr;
1056
1057 auto& target = shadow ? static_cast<DocumentOrShadowRoot&>(*shadow)
1058 : static_cast<DocumentOrShadowRoot&>(*mDocument);
1059
1060 // XXX Need to cancel pending sheet loads for this element, if any
1061
1062 int32_t sheetCount = target.SheetCount();
1063
1064 /*
1065 * Start the walk at the _end_ of the list, since in the typical
1066 * case we'll just want to append anyway. We want to break out of
1067 * the loop when insertionPoint points to just before the index we
1068 * want to insert at. In other words, when we leave the loop
1069 * insertionPoint is the index of the stylesheet that immediately
1070 * precedes the one we're inserting.
1071 */
1072 int32_t insertionPoint = sheetCount - 1;
1073 for (; insertionPoint >= 0; --insertionPoint) {
1074 nsINode* sheetOwner = target.SheetAt(insertionPoint)->GetOwnerNode();
1075 if (sheetOwner && !aOwningNode) {
1076 // Keep moving; all sheets with a sheetOwner come after all
1077 // sheets without a linkingNode
1078 continue;
1079 }
1080
1081 if (!sheetOwner) {
1082 // Aha! The current sheet has no sheet owner, so we want to insert after
1083 // it no matter whether we have a linking content or not.
1084 break;
1085 }
1086
1087 MOZ_ASSERT(aOwningNode != sheetOwner,
1088 "Why do we still have our old sheet?");
1089
1090 // Have to compare
1091 if (nsContentUtils::PositionIsBefore(sheetOwner, aOwningNode)) {
1092 // The current sheet comes before us, and it better be the first
1093 // such, because now we break
1094 break;
1095 }
1096 }
1097
1098 ++insertionPoint;
1099
1100 if (shadow) {
1101 shadow->InsertSheetAt(insertionPoint, aSheet);
1102 } else {
1103 mDocument->InsertSheetAt(insertionPoint, aSheet);
1104 }
1105
1106 LOG((" Inserting into target (doc: %d) at position %d",
1107 target.AsNode().IsDocument(), insertionPoint));
1108 }
1109
1110 /**
1111 * InsertChildSheet handles ordering of @import-ed sheet in their
1112 * parent sheets. Here we want to just insert based on order of the
1113 * @import rules that imported the sheets. In theory we can't just
1114 * append to the end because the CSSOM can insert @import rules. In
1115 * practice, we get the call to load the child sheet before the CSSOM
1116 * has finished inserting the @import rule, so we have no idea where
1117 * to put it anyway. So just append for now. (In the future if we
1118 * want to insert the sheet at the correct position, we'll need to
1119 * restore CSSStyleSheet::InsertStyleSheetAt, which was removed in
1120 * bug 1220506.)
1121 */
1122 void Loader::InsertChildSheet(StyleSheet& aSheet, StyleSheet& aParentSheet) {
1123 LOG(("css::Loader::InsertChildSheet"));
1124
1125 // child sheets should always start out enabled, even if they got
1126 // cloned off of top-level sheets which were disabled
1127 aSheet.SetEnabled(true);
1128 aParentSheet.AppendStyleSheet(aSheet);
1129
1130 LOG((" Inserting into parent sheet"));
1131 }
1132
1133 /**
1134 * LoadSheet handles the actual load of a sheet. If the load is
1135 * supposed to be synchronous it just opens a channel synchronously
1136 * using the given uri, wraps the resulting stream in a converter
1137 * stream and calls ParseSheet. Otherwise it tries to look for an
1138 * existing load for this URI and piggyback on it. Failing all that,
1139 * a new load is kicked off asynchronously.
1140 */
1141 nsresult Loader::LoadSheet(SheetLoadData& aLoadData, SheetState aSheetState,
1142 PendingLoad aPendingLoad) {
1143 LOG(("css::Loader::LoadSheet"));
1144 MOZ_ASSERT(aLoadData.mURI, "Need a URI to load");
1145 MOZ_ASSERT(aLoadData.mSheet, "Need a sheet to load into");
1146 MOZ_ASSERT(aSheetState != SheetState::Complete, "Why bother?");
1147 MOZ_ASSERT(!aLoadData.mUseSystemPrincipal || aLoadData.mSyncLoad,
1148 "Shouldn't use system principal for async loads");
1149
1150 LOG_URI(" Load from: '%s'", aLoadData.mURI);
1151
1152 // If we're firing a pending load, this load is already accounted for the
1153 // first time it went through this function.
1154 if (aPendingLoad == PendingLoad::No) {
1155 if (aLoadData.BlocksLoadEvent()) {
1156 IncrementOngoingLoadCount();
1157 }
1158
1159 // We technically never defer non-top-level sheets, so this condition could
1160 // be outside the branch, but conceptually it should be here.
1161 if (aLoadData.mParentData) {
1162 ++aLoadData.mParentData->mPendingChildren;
1163 }
1164 }
1165
1166 nsresult rv = NS_OK;
1167
1168 if (!mDocument && !aLoadData.mIsNonDocumentSheet) {
1169 // No point starting the load; just release all the data and such.
1170 LOG_WARN((" No document and not non-document sheet; pre-dropping load"));
1171 SheetComplete(aLoadData, NS_BINDING_ABORTED);
1172 return NS_BINDING_ABORTED;
1173 }
1174
1175 SRIMetadata sriMetadata;
1176 aLoadData.mSheet->GetIntegrity(sriMetadata);
1177
1178 if (aLoadData.mSyncLoad) {
1179 LOG((" Synchronous load"));
1180 MOZ_ASSERT(!aLoadData.mObserver, "Observer for a sync load?");
1181 MOZ_ASSERT(aSheetState == SheetState::NeedsParser,
1182 "Sync loads can't reuse existing async loads");
1183
1184 // Create a StreamLoader instance to which we will feed
1185 // the data from the sync load. Do this before creating the
1186 // channel to make error recovery simpler.
1187 auto streamLoader = MakeRefPtr<StreamLoader>(aLoadData);
1188
1189 if (mDocument) {
1190 net::PredictorLearn(aLoadData.mURI, mDocument->GetDocumentURI(),
1191 nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE,
1192 mDocument);
1193 }
1194
1195 nsSecurityFlags securityFlags =
1196 nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT |
1197 nsILoadInfo::SEC_ALLOW_CHROME;
1198
1199 nsContentPolicyType contentPolicyType =
1200 aLoadData.mPreloadKind == StylePreloadKind::None
1201 ? nsIContentPolicy::TYPE_INTERNAL_STYLESHEET
1202 : nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD;
1203
1204 // Just load it
1205 nsCOMPtr<nsIChannel> channel;
1206 // Note that we are calling NS_NewChannelWithTriggeringPrincipal() with both
1207 // a node and a principal.
1208 // This is because of a case where the node is the document being styled and
1209 // the principal is the stylesheet (perhaps from a different origin) that is
1210 // applying the styles.
1211 if (aLoadData.mRequestingNode) {
1212 rv = NS_NewChannelWithTriggeringPrincipal(
1213 getter_AddRefs(channel), aLoadData.mURI, aLoadData.mRequestingNode,
1214 aLoadData.mTriggeringPrincipal, securityFlags, contentPolicyType);
1215 } else {
1216 MOZ_ASSERT(aLoadData.mTriggeringPrincipal->Equals(LoaderPrincipal()));
1217 auto result = URLPreloader::ReadURI(aLoadData.mURI);
1218 if (result.isOk()) {
1219 nsCOMPtr<nsIInputStream> stream;
1220 MOZ_TRY(
1221 NS_NewCStringInputStream(getter_AddRefs(stream), result.unwrap()));
1222
1223 rv = NS_NewInputStreamChannel(
1224 getter_AddRefs(channel), aLoadData.mURI, stream.forget(),
1225 aLoadData.mTriggeringPrincipal, securityFlags, contentPolicyType);
1226 } else {
1227 rv = NS_NewChannel(getter_AddRefs(channel), aLoadData.mURI,
1228 aLoadData.mTriggeringPrincipal, securityFlags,
1229 contentPolicyType);
1230 }
1231 }
1232 if (NS_FAILED(rv)) {
1233 LOG_ERROR((" Failed to create channel"));
1234 streamLoader->ChannelOpenFailed(rv);
1235 SheetComplete(aLoadData, rv);
1236 return rv;
1237 }
1238
1239 // snapshot the nonce at load start time for performing CSP checks
1240 if (contentPolicyType == nsIContentPolicy::TYPE_INTERNAL_STYLESHEET) {
1241 if (aLoadData.mRequestingNode) {
1242 // TODO(bug 1607009) move to SheetLoadData
1243 nsString* cspNonce = static_cast<nsString*>(
1244 aLoadData.mRequestingNode->GetProperty(nsGkAtoms::nonce));
1245 if (cspNonce) {
1246 nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
1247 loadInfo->SetCspNonce(*cspNonce);
1248 }
1249 }
1250 }
1251
1252 nsCOMPtr<nsIInputStream> stream;
1253 rv = channel->Open(getter_AddRefs(stream));
1254
1255 if (NS_FAILED(rv)) {
1256 LOG_ERROR((" Failed to open URI synchronously"));
1257 streamLoader->ChannelOpenFailed(rv);
1258 SheetComplete(aLoadData, rv);
1259 return rv;
1260 }
1261
1262 // Force UA sheets to be UTF-8.
1263 // XXX this is only necessary because the default in
1264 // SheetLoadData::OnDetermineCharset is wrong (bug 521039).
1265 channel->SetContentCharset("UTF-8"_ns);
1266
1267 // Manually feed the streamloader the contents of the stream.
1268 // This will call back into OnStreamComplete
1269 // and thence to ParseSheet. Regardless of whether this fails,
1270 // SheetComplete has been called.
1271 return nsSyncLoadService::PushSyncStreamToListener(stream.forget(),
1272 streamLoader, channel);
1273 }
1274
1275 SheetLoadDataHashKey key(aLoadData);
1276
1277 auto preloadKey = PreloadHashKey::CreateAsStyle(aLoadData);
1278 bool coalescedLoad = false;
1279 if (mSheets) {
1280 // If we have at least one other load ongoing, then we can defer it until
1281 // all non-pending loads are done.
1282 if (aSheetState == SheetState::NeedsParser &&
1283 aPendingLoad == PendingLoad::No && aLoadData.ShouldDefer() &&
1284 mOngoingLoadCount > mPendingLoadCount + 1) {
1285 LOG((" Deferring sheet load"));
1286 ++mPendingLoadCount;
1287 mSheets->DeferSheetLoad(key, aLoadData);
1288 return NS_OK;
1289 }
1290
1291 if ((coalescedLoad = mSheets->CoalesceLoad(key, aLoadData, aSheetState))) {
1292 if (aSheetState == SheetState::Pending) {
1293 ++mPendingLoadCount;
1294 return NS_OK;
1295 }
1296 }
1297 }
1298
1299 aLoadData.NotifyOpen(preloadKey, mDocument, aLoadData.IsLinkRelPreload());
1300 if (coalescedLoad) {
1301 // All done here; once the load completes we'll be marked complete
1302 // automatically.
1303 return NS_OK;
1304 }
1305
1306 nsCOMPtr<nsILoadGroup> loadGroup;
1307 nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
1308 if (mDocument) {
1309 loadGroup = mDocument->GetDocumentLoadGroup();
1310 // load for a document with no loadgrup indicates that something is
1311 // completely bogus, let's bail out early.
1312 if (!loadGroup) {
1313 LOG_ERROR((" Failed to query loadGroup from document"));
1314 SheetComplete(aLoadData, NS_ERROR_UNEXPECTED);
1315 return NS_ERROR_UNEXPECTED;
1316 }
1317
1318 cookieJarSettings = mDocument->CookieJarSettings();
1319 }
1320
1321 #ifdef DEBUG
1322 AutoRestore<bool> syncCallbackGuard(mSyncCallback);
1323 mSyncCallback = true;
1324 #endif
1325
1326 CORSMode ourCORSMode = aLoadData.mSheet->GetCORSMode();
1327 nsSecurityFlags securityFlags =
1328 ourCORSMode == CORS_NONE
1329 ? nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT
1330 : nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT;
1331 if (ourCORSMode == CORS_ANONYMOUS) {
1332 securityFlags |= nsILoadInfo::SEC_COOKIES_SAME_ORIGIN;
1333 } else if (ourCORSMode == CORS_USE_CREDENTIALS) {
1334 securityFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE;
1335 }
1336 securityFlags |= nsILoadInfo::SEC_ALLOW_CHROME;
1337
1338 nsContentPolicyType contentPolicyType =
1339 aLoadData.mPreloadKind == StylePreloadKind::None
1340 ? nsIContentPolicy::TYPE_INTERNAL_STYLESHEET
1341 : nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD;
1342
1343 nsCOMPtr<nsIChannel> channel;
1344 // Note we are calling NS_NewChannelWithTriggeringPrincipal here with a node
1345 // and a principal. This is because of a case where the node is the document
1346 // being styled and the principal is the stylesheet (perhaps from a different
1347 // origin) that is applying the styles.
1348 if (aLoadData.mRequestingNode) {
1349 rv = NS_NewChannelWithTriggeringPrincipal(
1350 getter_AddRefs(channel), aLoadData.mURI, aLoadData.mRequestingNode,
1351 aLoadData.mTriggeringPrincipal, securityFlags, contentPolicyType,
1352 /* PerformanceStorage */ nullptr, loadGroup);
1353 } else {
1354 MOZ_ASSERT(aLoadData.mTriggeringPrincipal->Equals(LoaderPrincipal()));
1355 rv = NS_NewChannel(getter_AddRefs(channel), aLoadData.mURI,
1356 aLoadData.mTriggeringPrincipal, securityFlags,
1357 contentPolicyType, cookieJarSettings,
1358 /* aPerformanceStorage */ nullptr, loadGroup);
1359 }
1360
1361 if (NS_FAILED(rv)) {
1362 LOG_ERROR((" Failed to create channel"));
1363 SheetComplete(aLoadData, rv);
1364 return rv;
1365 }
1366
1367 // snapshot the nonce at load start time for performing CSP checks
1368 if (contentPolicyType == nsIContentPolicy::TYPE_INTERNAL_STYLESHEET) {
1369 if (aLoadData.mRequestingNode) {
1370 // TODO(bug 1607009) move to SheetLoadData
1371 nsString* cspNonce = static_cast<nsString*>(
1372 aLoadData.mRequestingNode->GetProperty(nsGkAtoms::nonce));
1373 if (cspNonce) {
1374 nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
1375 loadInfo->SetCspNonce(*cspNonce);
1376 }
1377 }
1378 }
1379
1380 if (!aLoadData.ShouldDefer()) {
1381 if (nsCOMPtr<nsIClassOfService> cos = do_QueryInterface(channel)) {
1382 cos->AddClassFlags(nsIClassOfService::Leader);
1383 }
1384 if (aLoadData.IsLinkRelPreload()) {
1385 SheetLoadData::PrioritizeAsPreload(channel);
1386 SheetLoadData::AddLoadBackgroundFlag(channel);
1387 }
1388 }
1389
1390 if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(channel)) {
1391 if (nsCOMPtr<nsIReferrerInfo> referrerInfo = aLoadData.ReferrerInfo()) {
1392 rv = httpChannel->SetReferrerInfo(referrerInfo);
1393 Unused << NS_WARN_IF(NS_FAILED(rv));
1394 }
1395
1396 nsCOMPtr<nsIHttpChannelInternal> internalChannel =
1397 do_QueryInterface(httpChannel);
1398 if (internalChannel) {
1399 rv = internalChannel->SetIntegrityMetadata(
1400 sriMetadata.GetIntegrityString());
1401 NS_ENSURE_SUCCESS(rv, rv);
1402 }
1403
1404 // Set the initiator type
1405 if (nsCOMPtr<nsITimedChannel> timedChannel =
1406 do_QueryInterface(httpChannel)) {
1407 if (aLoadData.mParentData) {
1408 timedChannel->SetInitiatorType(u"css"_ns);
1409
1410 // This is a child sheet load.
1411 //
1412 // The resource timing of the sub-resources that a document loads
1413 // should normally be reported to the document. One exception is any
1414 // sub-resources of any cross-origin resources that are loaded. We
1415 // don't mind reporting timing data for a direct child cross-origin
1416 // resource since the resource that linked to it (and hence potentially
1417 // anything in that parent origin) is aware that the cross-origin
1418 // resources is to be loaded. However, we do not want to report
1419 // timings for any sub-resources that a cross-origin resource may load
1420 // since that obviously leaks information about what the cross-origin
1421 // resource loads, which is bad.
1422 //
1423 // In addition to checking whether we're an immediate child resource of
1424 // a cross-origin resource (by checking if mIsCrossOriginNoCORS is set
1425 // to true on our parent), we also check our parent to see whether it
1426 // itself is a sub-resource of a cross-origin resource by checking
1427 // mBlockResourceTiming. If that is set then we too are such a
1428 // sub-resource and so we set the flag on ourself too to propagate it
1429 // on down.
1430 if (aLoadData.mParentData->mIsCrossOriginNoCORS ||
1431 aLoadData.mParentData->mBlockResourceTiming) {
1432 // Set a flag so any other stylesheet triggered by this one will
1433 // not be reported
1434 aLoadData.mBlockResourceTiming = true;
1435
1436 // Mark the channel so PerformanceMainThread::AddEntry will not
1437 // report the resource.
1438 timedChannel->SetReportResourceTiming(false);
1439 }
1440
1441 } else {
1442 timedChannel->SetInitiatorType(u"link"_ns);
1443 }
1444 }
1445 }
1446
1447 // Now tell the channel we expect text/css data back.... We do
1448 // this before opening it, so it's only treated as a hint.
1449 channel->SetContentType("text/css"_ns);
1450
1451 // We don't have to hold on to the stream loader. The ownership
1452 // model is: Necko owns the stream loader, which owns the load data,
1453 // which owns us
1454 auto streamLoader = MakeRefPtr<StreamLoader>(aLoadData);
1455 if (mDocument) {
1456 net::PredictorLearn(aLoadData.mURI, mDocument->GetDocumentURI(),
1457 nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE, mDocument);
1458 }
1459
1460 rv = channel->AsyncOpen(streamLoader);
1461 if (NS_FAILED(rv)) {
1462 LOG_ERROR((" Failed to create stream loader"));
1463 streamLoader->ChannelOpenFailed(rv);
1464 // NOTE: NotifyStop will be done in SheetComplete -> NotifyObservers.
1465 aLoadData.NotifyStart(channel);
1466 SheetComplete(aLoadData, rv);
1467 return rv;
1468 }
1469
1470 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
1471 if (nsCOMPtr<nsIHttpChannelInternal> hci = do_QueryInterface(channel)) {
1472 hci->DoDiagnosticAssertWhenOnStopNotCalledOnDestroy();
1473 }
1474 #endif
1475
1476 if (mSheets) {
1477 mSheets->LoadStarted(key, aLoadData);
1478 }
1479 return NS_OK;
1480 }
1481
1482 /**
1483 * ParseSheet handles parsing the data stream.
1484 */
1485 Loader::Completed Loader::ParseSheet(const nsACString& aBytes,
1486 SheetLoadData& aLoadData,
1487 AllowAsyncParse aAllowAsync) {
1488 LOG(("css::Loader::ParseSheet"));
1489 if (aLoadData.mURI) {
1490 LOG_URI(" Load succeeded for URI: '%s', parsing", aLoadData.mURI);
1491 }
1492 AUTO_PROFILER_LABEL("css::Loader::ParseSheet", LAYOUT_CSSParsing);
1493
1494 ++mParsedSheetCount;
1495
1496 aLoadData.mIsBeingParsed = true;
1497
1498 StyleSheet* sheet = aLoadData.mSheet;
1499 MOZ_ASSERT(sheet);
1500
1501 // Some cases, like inline style and UA stylesheets, need to be parsed
1502 // synchronously. The former may trigger child loads, the latter must not.
1503 if (aLoadData.mSyncLoad || aAllowAsync == AllowAsyncParse::No) {
1504 sheet->ParseSheetSync(this, aBytes, &aLoadData, aLoadData.mLineNumber);
1505 aLoadData.mIsBeingParsed = false;
1506
1507 bool noPendingChildren = aLoadData.mPendingChildren == 0;
1508 MOZ_ASSERT_IF(aLoadData.mSyncLoad, noPendingChildren);
1509 if (noPendingChildren) {
1510 SheetComplete(aLoadData, NS_OK);
1511 return Completed::Yes;
1512 }
1513 return Completed::No;
1514 }
1515
1516 // This parse does not need to be synchronous. \o/
1517 //
1518 // Note that load is already blocked from IncrementOngoingLoadCount(), and
1519 // will be unblocked from SheetFinishedParsingAsync which will end up in
1520 // NotifyObservers as needed.
1521 nsCOMPtr<nsISerialEventTarget> target = DispatchTarget();
1522 sheet->ParseSheet(*this, aBytes, aLoadData)
1523 ->Then(
1524 target, __func__,
1525 [loadData = RefPtr<SheetLoadData>(&aLoadData)](bool aDummy) {
1526 MOZ_ASSERT(NS_IsMainThread());
1527 loadData->SheetFinishedParsingAsync();
1528 },
1529 [] { MOZ_CRASH("rejected parse promise"); });
1530 return Completed::No;
1531 }
1532
1533 void Loader::NotifyObservers(SheetLoadData& aData, nsresult aStatus) {
1534 RecordUseCountersIfNeeded(mDocument, aData.mUseCounters.get());
1535 if (aData.mURI) {
1536 mLoadsPerformed.PutEntry(SheetLoadDataHashKey(aData));
1537 aData.NotifyStop(aStatus);
1538 // NOTE(emilio): This needs to happen before notifying observers, as
1539 // FontFaceSet for example checks for pending sheet loads from the
1540 // StyleSheetLoaded callback.
1541 if (aData.BlocksLoadEvent()) {
1542 DecrementOngoingLoadCount();
1543 }
1544 }
1545
1546 if (aData.mMustNotify) {
1547 if (aData.mObserver) {
1548 LOG((" Notifying observer %p for data %p. deferred: %d",
1549 aData.mObserver.get(), &aData, aData.ShouldDefer()));
1550 aData.mObserver->StyleSheetLoaded(aData.mSheet, aData.ShouldDefer(),
1551 aStatus);
1552 }
1553
1554 for (nsCOMPtr<nsICSSLoaderObserver> obs : mObservers.ForwardRange()) {
1555 LOG((" Notifying global observer %p for data %p. deferred: %d",
1556 obs.get(), &aData, aData.ShouldDefer()));
1557 obs->StyleSheetLoaded(aData.mSheet, aData.ShouldDefer(), aStatus);
1558 }
1559 }
1560
1561 if (mPendingLoadCount && mPendingLoadCount == mOngoingLoadCount) {
1562 LOG((" No more loading sheets; starting deferred loads"));
1563 StartDeferredLoads();
1564 }
1565 }
1566
1567 /**
1568 * SheetComplete is the do-it-all cleanup function. It removes the
1569 * load data from the "loading" hashtable, adds the sheet to the
1570 * "completed" hashtable, massages the XUL cache, handles siblings of
1571 * the load data (other loads for the same URI), handles unblocking
1572 * blocked parent loads as needed, and most importantly calls
1573 * NS_RELEASE on the load data to destroy the whole mess.
1574 */
1575 void Loader::SheetComplete(SheetLoadData& aLoadData, nsresult aStatus) {
1576 LOG(("css::Loader::SheetComplete, status: 0x%" PRIx32,
1577 static_cast<uint32_t>(aStatus)));
1578 SharedStyleSheetCache::LoadCompleted(mSheets.get(), aLoadData, aStatus);
1579 }
1580
1581 // static
1582 void Loader::MarkLoadTreeFailed(SheetLoadData& aLoadData,
1583 Loader* aOnlyForLoader) {
1584 if (aLoadData.mURI) {
1585 LOG_URI(" Load failed: '%s'", aLoadData.mURI);
1586 }
1587
1588 SheetLoadData* data = &aLoadData;
1589 do {
1590 if (!aOnlyForLoader || aOnlyForLoader == data->mLoader) {
1591 data->mLoadFailed = true;
1592 data->mSheet->MaybeRejectReplacePromise();
1593 }
1594
1595 if (data->mParentData) {
1596 MarkLoadTreeFailed(*data->mParentData, aOnlyForLoader);
1597 }
1598
1599 data = data->mNext;
1600 } while (data);
1601 }
1602
1603 RefPtr<StyleSheet> Loader::LookupInlineSheetInCache(const nsAString& aBuffer) {
1604 auto result = mInlineSheets.Lookup(aBuffer);
1605 if (!result) {
1606 return nullptr;
1607 }
1608 if (result.Data()->HasModifiedRules()) {
1609 // Remove it now that we know that we're never going to use this stylesheet
1610 // again.
1611 result.Remove();
1612 return nullptr;
1613 }
1614 return result.Data()->Clone(nullptr, nullptr, nullptr, nullptr);
1615 }
1616
1617 void Loader::MaybeNotifyPreloadUsed(SheetLoadData& aData) {
1618 if (!mDocument) {
1619 return;
1620 }
1621
1622 auto key = PreloadHashKey::CreateAsStyle(aData);
1623 RefPtr<PreloaderBase> preload = mDocument->Preloads().LookupPreload(key);
1624 if (!preload) {
1625 return;
1626 }
1627
1628 preload->NotifyUsage();
1629 }
1630
1631 Result<Loader::LoadSheetResult, nsresult> Loader::LoadInlineStyle(
1632 const SheetInfo& aInfo, const nsAString& aBuffer, uint32_t aLineNumber,
1633 nsICSSLoaderObserver* aObserver) {
1634 LOG(("css::Loader::LoadInlineStyle"));
1635 MOZ_ASSERT(aInfo.mContent);
1636
1637 if (!mEnabled) {
1638 LOG_WARN((" Not enabled"));
1639 return Err(NS_ERROR_NOT_AVAILABLE);
1640 }
1641
1642 if (!mDocument) {
1643 return Err(NS_ERROR_NOT_INITIALIZED);
1644 }
1645
1646 MOZ_ASSERT(LinkStyle::FromNodeOrNull(aInfo.mContent),
1647 "Element is not a style linking element!");
1648
1649 // Since we're not planning to load a URI, no need to hand a principal to the
1650 // load data or to CreateSheet().
1651
1652 // Check IsAlternateSheet now, since it can mutate our document.
1653 auto isAlternate = IsAlternateSheet(aInfo.mTitle, aInfo.mHasAlternateRel);
1654 LOG((" Sheet is alternate: %d", static_cast<int>(isAlternate)));
1655
1656 // Use the document's base URL so that @import in the inline sheet picks up
1657 // the right base.
1658 nsIURI* baseURI = aInfo.mContent->GetBaseURI();
1659 nsIURI* sheetURI = aInfo.mContent->OwnerDoc()->GetDocumentURI();
1660 nsIURI* originalURI = nullptr;
1661
1662 MOZ_ASSERT(aInfo.mIntegrity.IsEmpty());
1663
1664 nsIPrincipal* loadingPrincipal = LoaderPrincipal();
1665 nsIPrincipal* principal = aInfo.mTriggeringPrincipal
1666 ? aInfo.mTriggeringPrincipal.get()
1667 : loadingPrincipal;
1668
1669 // We only cache sheets if in shadow trees, since regular document sheets are
1670 // likely to be unique.
1671 const bool isWorthCaching = aInfo.mContent->IsInShadowTree();
1672 RefPtr<StyleSheet> sheet;
1673 if (isWorthCaching) {
1674 sheet = LookupInlineSheetInCache(aBuffer);
1675 }
1676 const bool sheetFromCache = !!sheet;
1677 if (!sheet) {
1678 sheet = MakeRefPtr<StyleSheet>(eAuthorSheetFeatures, aInfo.mCORSMode,
1679 SRIMetadata{});
1680 sheet->SetURIs(sheetURI, originalURI, baseURI);
1681 nsCOMPtr<nsIReferrerInfo> referrerInfo =
1682 ReferrerInfo::CreateForInternalCSSResources(aInfo.mContent->OwnerDoc());
1683 sheet->SetReferrerInfo(referrerInfo);
1684
1685 nsIPrincipal* sheetPrincipal = principal;
1686 if (aInfo.mTriggeringPrincipal) {
1687 // The triggering principal may be an expanded principal, which is safe to
1688 // use for URL security checks, but not as the loader principal for a
1689 // stylesheet. So treat this as principal inheritance, and downgrade if
1690 // necessary.
1691 sheetPrincipal =
1692 BasePrincipal::Cast(aInfo.mTriggeringPrincipal)->PrincipalToInherit();
1693 }
1694
1695 // We never actually load this, so just set its principal directly
1696 sheet->SetPrincipal(sheetPrincipal);
1697 }
1698
1699 auto matched = PrepareSheet(*sheet, aInfo.mTitle, aInfo.mMedia, nullptr,
1700 isAlternate, aInfo.mIsExplicitlyEnabled);
1701
1702 if (auto* linkStyle = LinkStyle::FromNodeOrNull(aInfo.mContent)) {
1703 linkStyle->SetStyleSheet(sheet);
1704 }
1705 if (sheet->IsComplete()) {
1706 InsertSheetInTree(*sheet, aInfo.mContent);
1707 }
1708
1709 Completed completed;
1710 if (sheetFromCache) {
1711 MOZ_ASSERT(sheet->IsComplete());
1712 completed = Completed::Yes;
1713 } else {
1714 auto data = MakeRefPtr<SheetLoadData>(
1715 this, aInfo.mTitle, nullptr, sheet, false, aInfo.mContent, isAlternate,
1716 matched, StylePreloadKind::None, aObserver, principal,
1717 aInfo.mReferrerInfo, aInfo.mContent);
1718 data->mLineNumber = aLineNumber;
1719
1720 // Parse completion releases the load data.
1721 //
1722 // Note that we need to parse synchronously, since the web expects that the
1723 // effects of inline stylesheets are visible immediately (aside from
1724 // @imports).
1725 NS_ConvertUTF16toUTF8 utf8(aBuffer);
1726 completed = ParseSheet(utf8, *data, AllowAsyncParse::No);
1727 if (completed == Completed::Yes) {
1728 // TODO(emilio): Try to cache sheets with @import rules, maybe?
1729 if (isWorthCaching) {
1730 mInlineSheets.InsertOrUpdate(aBuffer, std::move(sheet));
1731 }
1732 } else {
1733 data->mMustNotify = true;
1734 }
1735 }
1736
1737 return LoadSheetResult{completed, isAlternate, matched};
1738 }
1739
1740 Result<Loader::LoadSheetResult, nsresult> Loader::LoadStyleLink(
1741 const SheetInfo& aInfo, nsICSSLoaderObserver* aObserver) {
1742 MOZ_ASSERT(aInfo.mURI, "Must have URL to load");
1743 LOG(("css::Loader::LoadStyleLink"));
1744 LOG_URI(" Link uri: '%s'", aInfo.mURI);
1745 LOG((" Link title: '%s'", NS_ConvertUTF16toUTF8(aInfo.mTitle).get()));
1746 LOG((" Link media: '%s'", NS_ConvertUTF16toUTF8(aInfo.mMedia).get()));
1747 LOG((" Link alternate rel: %d", aInfo.mHasAlternateRel));
1748
1749 if (!mEnabled) {
1750 LOG_WARN((" Not enabled"));
1751 return Err(NS_ERROR_NOT_AVAILABLE);
1752 }
1753
1754 if (!mDocument) {
1755 return Err(NS_ERROR_NOT_INITIALIZED);
1756 }
1757
1758 MOZ_ASSERT_IF(aInfo.mContent,
1759 aInfo.mContent->NodePrincipal() == mDocument->NodePrincipal());
1760 nsIPrincipal* loadingPrincipal = LoaderPrincipal();
1761 nsIPrincipal* principal = aInfo.mTriggeringPrincipal
1762 ? aInfo.mTriggeringPrincipal.get()
1763 : loadingPrincipal;
1764
1765 nsINode* context = aInfo.mContent;
1766 if (!context) {
1767 context = mDocument;
1768 }
1769
1770 bool syncLoad = aInfo.mContent && aInfo.mContent->IsInUAWidget() &&
1771 IsChromeURI(aInfo.mURI);
1772 LOG((" Link sync load: '%s'", syncLoad ? "true" : "false"));
1773 MOZ_ASSERT_IF(syncLoad, !aObserver);
1774
1775 nsresult rv =
1776 CheckContentPolicy(loadingPrincipal, principal, aInfo.mURI, context,
1777 aInfo.mNonce, StylePreloadKind::None);
1778 if (NS_WARN_IF(NS_FAILED(rv))) {
1779 // Don't fire the error event if our document is loaded as data. We're
1780 // supposed to not even try to do loads in that case... Unfortunately, we
1781 // implement that via nsDataDocumentContentPolicy, which doesn't have a good
1782 // way to communicate back to us that _it_ is the thing that blocked the
1783 // load.
1784 if (aInfo.mContent && !mDocument->IsLoadedAsData()) {
1785 // Fire an async error event on it.
1786 RefPtr<AsyncEventDispatcher> loadBlockingAsyncDispatcher =
1787 new LoadBlockingAsyncEventDispatcher(aInfo.mContent, u"error"_ns,
1788 CanBubble::eNo,
1789 ChromeOnlyDispatch::eNo);
1790 loadBlockingAsyncDispatcher->PostDOMEvent();
1791 }
1792 return Err(rv);
1793 }
1794
1795 // Check IsAlternateSheet now, since it can mutate our document and make
1796 // pending sheets go to the non-pending state.
1797 auto isAlternate = IsAlternateSheet(aInfo.mTitle, aInfo.mHasAlternateRel);
1798 auto [sheet, state] = CreateSheet(aInfo, eAuthorSheetFeatures, syncLoad,
1799 StylePreloadKind::None);
1800
1801 LOG((" Sheet is alternate: %d", static_cast<int>(isAlternate)));
1802
1803 auto matched = PrepareSheet(*sheet, aInfo.mTitle, aInfo.mMedia, nullptr,
1804 isAlternate, aInfo.mIsExplicitlyEnabled);
1805
1806 if (auto* linkStyle = LinkStyle::FromNodeOrNull(aInfo.mContent)) {
1807 linkStyle->SetStyleSheet(sheet);
1808 }
1809 if (sheet->IsComplete()) {
1810 InsertSheetInTree(*sheet, aInfo.mContent);
1811 }
1812
1813 // We may get here with no content for Link: headers for example.
1814 MOZ_ASSERT(!aInfo.mContent || LinkStyle::FromNode(*aInfo.mContent),
1815 "If there is any node, it should be a LinkStyle");
1816 auto data = MakeRefPtr<SheetLoadData>(
1817 this, aInfo.mTitle, aInfo.mURI, sheet, syncLoad, aInfo.mContent,
1818 isAlternate, matched, StylePreloadKind::None, aObserver, principal,
1819 aInfo.mReferrerInfo, context);
1820
1821 MaybeNotifyPreloadUsed(*data);
1822
1823 if (state == SheetState::Complete) {
1824 LOG((" Sheet already complete: 0x%p", sheet.get()));
1825 if (aObserver || !mObservers.IsEmpty() || aInfo.mContent) {
1826 rv = PostLoadEvent(std::move(data));
1827 if (NS_FAILED(rv)) {
1828 return Err(rv);
1829 }
1830 } else {
1831 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
1832 // We don't have to notify anyone of this load, as it was complete, so
1833 // drop it intentionally.
1834 data->mIntentionallyDropped = true;
1835 #endif
1836 }
1837
1838 // The load hasn't been completed yet, will be done in PostLoadEvent.
1839 return LoadSheetResult{Completed::No, isAlternate, matched};
1840 }
1841
1842 // Now we need to actually load it.
1843 auto result = LoadSheetResult{Completed::No, isAlternate, matched};
1844
1845 MOZ_ASSERT(result.ShouldBlock() == !data->ShouldDefer(),
1846 "These should better match!");
1847
1848 // Load completion will free the data
1849 rv = LoadSheet(*data, state);
1850 if (NS_FAILED(rv)) {
1851 return Err(rv);
1852 }
1853
1854 if (!syncLoad) {
1855 data->mMustNotify = true;
1856 }
1857 return result;
1858 }
1859
1860 static bool HaveAncestorDataWithURI(SheetLoadData& aData, nsIURI* aURI) {
1861 if (!aData.mURI) {
1862 // Inline style; this won't have any ancestors
1863 MOZ_ASSERT(!aData.mParentData, "How does inline style have a parent?");
1864 return false;
1865 }
1866
1867 bool equal;
1868 if (NS_FAILED(aData.mURI->Equals(aURI, &equal)) || equal) {
1869 return true;
1870 }
1871
1872 // Datas down the mNext chain have the same URI as aData, so we
1873 // don't have to compare to them. But they might have different
1874 // parents, and we have to check all of those.
1875 SheetLoadData* data = &aData;
1876 do {
1877 if (data->mParentData &&
1878 HaveAncestorDataWithURI(*data->mParentData, aURI)) {
1879 return true;
1880 }
1881
1882 data = data->mNext;
1883 } while (data);
1884
1885 return false;
1886 }
1887
1888 nsresult Loader::LoadChildSheet(StyleSheet& aParentSheet,
1889 SheetLoadData* aParentData, nsIURI* aURL,
1890 dom::MediaList* aMedia,
1891 LoaderReusableStyleSheets* aReusableSheets) {
1892 LOG(("css::Loader::LoadChildSheet"));
1893 MOZ_ASSERT(aURL, "Must have a URI to load");
1894
1895 if (!mEnabled) {
1896 LOG_WARN((" Not enabled"));
1897 return NS_ERROR_NOT_AVAILABLE;
1898 }
1899
1900 LOG_URI(" Child uri: '%s'", aURL);
1901
1902 nsCOMPtr<nsINode> owningNode;
1903
1904 // Check for an associated document or shadow root: if none, don't bother
1905 // walking up the parent sheets.
1906 if (aParentSheet.GetAssociatedDocumentOrShadowRoot()) {
1907 StyleSheet* topSheet = &aParentSheet;
1908 while (StyleSheet* parent = topSheet->GetParentSheet()) {
1909 topSheet = parent;
1910 }
1911 owningNode = topSheet->GetOwnerNode();
1912 }
1913
1914 nsINode* context = nullptr;
1915 if (owningNode) {
1916 context = owningNode;
1917 MOZ_ASSERT(LoaderPrincipal() == owningNode->NodePrincipal());
1918 } else if (mDocument) {
1919 context = mDocument;
1920 }
1921
1922 nsIPrincipal* principal = aParentSheet.Principal();
1923 nsresult rv = CheckContentPolicy(LoaderPrincipal(), principal, aURL, context,
1924 u""_ns, StylePreloadKind::None);
1925 if (NS_WARN_IF(NS_FAILED(rv))) {
1926 if (aParentData) {
1927 MarkLoadTreeFailed(*aParentData);
1928 }
1929 return rv;
1930 }
1931
1932 nsCOMPtr<nsICSSLoaderObserver> observer;
1933
1934 if (aParentData) {
1935 LOG((" Have a parent load"));
1936 // Check for cycles
1937 if (HaveAncestorDataWithURI(*aParentData, aURL)) {
1938 // Houston, we have a loop, blow off this child and pretend this never
1939 // happened
1940 LOG_ERROR((" @import cycle detected, dropping load"));
1941 return NS_OK;
1942 }
1943
1944 NS_ASSERTION(aParentData->mSheet == &aParentSheet,
1945 "Unexpected call to LoadChildSheet");
1946 } else {
1947 LOG((" No parent load; must be CSSOM"));
1948 // No parent load data, so the sheet will need to be notified when
1949 // we finish, if it can be, if we do the load asynchronously.
1950 observer = &aParentSheet;
1951 }
1952
1953 // Now that we know it's safe to load this (passes security check and not a
1954 // loop) do so.
1955 RefPtr<StyleSheet> sheet;
1956 SheetState state;
1957 if (aReusableSheets && aReusableSheets->FindReusableStyleSheet(aURL, sheet)) {
1958 state = SheetState::Complete;
1959 } else {
1960 // For now, use CORS_NONE for child sheets
1961 std::tie(sheet, state) = CreateSheet(
1962 aURL, nullptr, principal, aParentSheet.ParsingMode(), CORS_NONE,
1963 aParentData ? aParentData->mEncoding : nullptr,
1964 u""_ns, // integrity is only checked on main sheet
1965 aParentData && aParentData->mSyncLoad, StylePreloadKind::None);
1966 PrepareSheet(*sheet, u""_ns, u""_ns, aMedia, IsAlternate::No,
1967 IsExplicitlyEnabled::No);
1968 }
1969
1970 MOZ_ASSERT(sheet);
1971 InsertChildSheet(*sheet, aParentSheet);
1972
1973 auto data = MakeRefPtr<SheetLoadData>(
1974 this, aURL, sheet, aParentData, observer, principal,
1975 aParentSheet.GetReferrerInfo(), context);
1976
1977 MaybeNotifyPreloadUsed(*data);
1978
1979 if (state == SheetState::Complete) {
1980 LOG((" Sheet already complete"));
1981 // We're completely done. No need to notify, even, since the
1982 // @import rule addition/modification will trigger the right style
1983 // changes automatically.
1984 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
1985 data->mIntentionallyDropped = true;
1986 #endif
1987 return NS_OK;
1988 }
1989
1990 bool syncLoad = data->mSyncLoad;
1991
1992 // Load completion will release the data
1993 rv = LoadSheet(*data, state);
1994 NS_ENSURE_SUCCESS(rv, rv);
1995
1996 if (!syncLoad) {
1997 data->mMustNotify = true;
1998 }
1999 return rv;
2000 }
2001
2002 Result<RefPtr<StyleSheet>, nsresult> Loader::LoadSheetSync(
2003 nsIURI* aURL, SheetParsingMode aParsingMode,
2004 UseSystemPrincipal aUseSystemPrincipal) {
2005 LOG(("css::Loader::LoadSheetSync"));
2006 nsCOMPtr<nsIReferrerInfo> referrerInfo = new ReferrerInfo(nullptr);
2007 return InternalLoadNonDocumentSheet(
2008 aURL, StylePreloadKind::None, aParsingMode, aUseSystemPrincipal, nullptr,
2009 referrerInfo, nullptr, CORS_NONE, u""_ns);
2010 }
2011
2012 Result<RefPtr<StyleSheet>, nsresult> Loader::LoadSheet(
2013 nsIURI* aURI, SheetParsingMode aParsingMode,
2014 UseSystemPrincipal aUseSystemPrincipal, nsICSSLoaderObserver* aObserver) {
2015 nsCOMPtr<nsIReferrerInfo> referrerInfo = new ReferrerInfo(nullptr);
2016 return InternalLoadNonDocumentSheet(
2017 aURI, StylePreloadKind::None, aParsingMode, aUseSystemPrincipal, nullptr,
2018 referrerInfo, aObserver, CORS_NONE, u""_ns);
2019 }
2020
2021 Result<RefPtr<StyleSheet>, nsresult> Loader::LoadSheet(
2022 nsIURI* aURL, StylePreloadKind aPreloadKind,
2023 const Encoding* aPreloadEncoding, nsIReferrerInfo* aReferrerInfo,
2024 nsICSSLoaderObserver* aObserver, CORSMode aCORSMode,
2025 const nsAString& aIntegrity) {
2026 LOG(("css::Loader::LoadSheet(aURL, aObserver) api call"));
2027 return InternalLoadNonDocumentSheet(
2028 aURL, aPreloadKind, eAuthorSheetFeatures, UseSystemPrincipal::No,
2029 aPreloadEncoding, aReferrerInfo, aObserver, aCORSMode, aIntegrity);
2030 }
2031
2032 Result<RefPtr<StyleSheet>, nsresult> Loader::InternalLoadNonDocumentSheet(
2033 nsIURI* aURL, StylePreloadKind aPreloadKind, SheetParsingMode aParsingMode,
2034 UseSystemPrincipal aUseSystemPrincipal, const Encoding* aPreloadEncoding,
2035 nsIReferrerInfo* aReferrerInfo, nsICSSLoaderObserver* aObserver,
2036 CORSMode aCORSMode, const nsAString& aIntegrity) {
2037 MOZ_ASSERT(aURL, "Must have a URI to load");
2038 MOZ_ASSERT(aUseSystemPrincipal == UseSystemPrincipal::No || !aObserver,
2039 "Shouldn't load system-principal sheets async");
2040 MOZ_ASSERT(aReferrerInfo, "Must have referrerInfo");
2041
2042 LOG_URI(" Non-document sheet uri: '%s'", aURL);
2043
2044 if (!mEnabled) {
2045 LOG_WARN((" Not enabled"));
2046 return Err(NS_ERROR_NOT_AVAILABLE);
2047 }
2048
2049 nsIPrincipal* loadingPrincipal = LoaderPrincipal();
2050 nsIPrincipal* triggeringPrincipal = loadingPrincipal;
2051 nsresult rv = CheckContentPolicy(loadingPrincipal, triggeringPrincipal, aURL,
2052 mDocument, u""_ns, aPreloadKind);
2053 if (NS_FAILED(rv)) {
2054 return Err(rv);
2055 }
2056
2057 bool syncLoad = !aObserver;
2058 auto [sheet, state] =
2059 CreateSheet(aURL, nullptr, triggeringPrincipal, aParsingMode, aCORSMode,
2060 aPreloadEncoding, aIntegrity, syncLoad, aPreloadKind);
2061
2062 PrepareSheet(*sheet, u""_ns, u""_ns, nullptr, IsAlternate::No,
2063 IsExplicitlyEnabled::No);
2064
2065 auto data = MakeRefPtr<SheetLoadData>(
2066 this, aURL, sheet, syncLoad, aUseSystemPrincipal, aPreloadKind,
2067 aPreloadEncoding, aObserver, triggeringPrincipal, aReferrerInfo,
2068 mDocument);
2069 if (state == SheetState::Complete) {
2070 LOG((" Sheet already complete"));
2071 if (aObserver || !mObservers.IsEmpty()) {
2072 rv = PostLoadEvent(std::move(data));
2073 if (NS_FAILED(rv)) {
2074 return Err(rv);
2075 }
2076 } else {
2077 // We don't have to notify anyone of this load, as it was complete, so
2078 // drop it intentionally.
2079 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
2080 data->mIntentionallyDropped = true;
2081 #endif
2082 }
2083 return sheet;
2084 }
2085
2086 rv = LoadSheet(*data, state);
2087 if (NS_FAILED(rv)) {
2088 return Err(rv);
2089 }
2090 if (aObserver) {
2091 data->mMustNotify = true;
2092 }
2093 return sheet;
2094 }
2095
2096 nsresult Loader::PostLoadEvent(RefPtr<SheetLoadData> aLoadData) {
2097 LOG(("css::Loader::PostLoadEvent"));
2098 mPostedEvents.AppendElement(aLoadData);
2099
2100 nsresult rv;
2101 RefPtr<SheetLoadData> runnable(aLoadData);
2102 if (mDocument) {
2103 rv = mDocument->Dispatch(TaskCategory::Other, runnable.forget());
2104 } else if (mDocGroup) {
2105 rv = mDocGroup->Dispatch(TaskCategory::Other, runnable.forget());
2106 } else {
2107 rv = SchedulerGroup::Dispatch(TaskCategory::Other, runnable.forget());
2108 }
2109
2110 if (NS_FAILED(rv)) {
2111 NS_WARNING("failed to dispatch stylesheet load event");
2112 mPostedEvents.RemoveElement(aLoadData);
2113 } else {
2114 if (aLoadData->BlocksLoadEvent()) {
2115 IncrementOngoingLoadCount();
2116 }
2117
2118 // We want to notify the observer for this data.
2119 aLoadData->mMustNotify = true;
2120 aLoadData->mSheetAlreadyComplete = true;
2121
2122 // If we get to this code, aSheet loaded correctly at some point, so
2123 // we can just schedule a load event and don't need to touch the
2124 // data's mLoadFailed. Note that we do this here and not from
2125 // inside our SheetComplete so that we don't end up running the load
2126 // event async.
2127 MOZ_ASSERT(!aLoadData->mLoadFailed, "Why are we marked as failed?");
2128 aLoadData->ScheduleLoadEventIfNeeded();
2129 }
2130
2131 return rv;
2132 }
2133
2134 void Loader::HandleLoadEvent(SheetLoadData& aEvent) {
2135 // XXXbz can't assert this yet.... May not have an observer because
2136 // we're unblocking the parser
2137 // NS_ASSERTION(aEvent->mObserver, "Must have observer");
2138 NS_ASSERTION(aEvent.mSheet, "Must have sheet");
2139
2140 mPostedEvents.RemoveElement(&aEvent);
2141 SheetComplete(aEvent, NS_OK);
2142 }
2143
2144 void Loader::Stop() {
2145 if (mSheets) {
2146 mSheets->CancelLoadsForLoader(*this);
2147 }
2148
2149 auto arr = std::move(mPostedEvents);
2150 for (auto& data : arr) {
2151 data->mIsCancelled = true;
2152 }
2153 }
2154
2155 bool Loader::HasPendingLoads() { return mOngoingLoadCount; }
2156
2157 void Loader::AddObserver(nsICSSLoaderObserver* aObserver) {
2158 MOZ_ASSERT(aObserver, "Must have observer");
2159 mObservers.AppendElementUnlessExists(aObserver);
2160 }
2161
2162 void Loader::RemoveObserver(nsICSSLoaderObserver* aObserver) {
2163 mObservers.RemoveElement(aObserver);
2164 }
2165
2166 void Loader::StartDeferredLoads() {
2167 if (mSheets && mPendingLoadCount) {
2168 mSheets->StartDeferredLoadsForLoader(
2169 *this, SharedStyleSheetCache::StartLoads::Always);
2170 }
2171 }
2172
2173 NS_IMPL_CYCLE_COLLECTION_CLASS(Loader)
2174
2175 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Loader)
2176 NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSheets);
2177 for (auto iter = tmp->mInlineSheets.Iter(); !iter.Done(); iter.Next()) {
2178 NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "Inline sheet cache in Loader");
2179 cb.NoteXPCOMChild(iter.UserData());
2180 }
2181 for (nsCOMPtr<nsICSSLoaderObserver>& obs : tmp->mObservers.ForwardRange()) {
2182 ImplCycleCollectionTraverse(cb, obs, "mozilla::css::Loader.mObservers");
2183 }
2184 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
2185
2186 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Loader)
2187 if (tmp->mSheets) {
2188 if (tmp->mDocument) {
2189 tmp->DeregisterFromSheetCache();
2190 }
2191 tmp->mSheets = nullptr;
2192 }
2193 tmp->mInlineSheets.Clear();
2194 tmp->mObservers.Clear();
2195 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
2196
2197 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(Loader, AddRef)
2198 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(Loader, Release)
2199
2200 size_t Loader::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
2201 size_t n = aMallocSizeOf(this);
2202
2203 n += mObservers.ShallowSizeOfExcludingThis(aMallocSizeOf);
2204
2205 n += mInlineSheets.ShallowSizeOfExcludingThis(aMallocSizeOf);
2206 for (auto iter = mInlineSheets.ConstIter(); !iter.Done(); iter.Next()) {
2207 n += iter.Key().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
2208 // If the sheet has a parent, then its parent will report it so we don't
2209 // have to worry about it here.
2210 const StyleSheet* sheet = iter.UserData();
2211 MOZ_ASSERT(!sheet->GetParentSheet(),
2212 "How did an @import rule end up here?");
2213 if (!sheet->GetOwnerNode()) {
2214 n += sheet->SizeOfIncludingThis(aMallocSizeOf);
2215 }
2216 }
2217
2218 // Measurement of the following members may be added later if DMD finds it is
2219 // worthwhile:
2220 // - mPostedEvents: transient, and should be small
2221 //
2222 // The following members aren't measured:
2223 // - mDocument, because it's a weak backpointer
2224
2225 return n;
2226 }
2227
2228 nsIPrincipal* Loader::LoaderPrincipal() const {
2229 if (mDocument) {
2230 return mDocument->NodePrincipal();
2231 }
2232 // Loaders without a document do system loads.
2233 return nsContentUtils::GetSystemPrincipal();
2234 }
2235
2236 nsIPrincipal* Loader::PartitionedPrincipal() const {
2237 if (mDocument && StaticPrefs::privacy_partition_network_state()) {
2238 return mDocument->PartitionedPrincipal();
2239 }
2240 return LoaderPrincipal();
2241 }
2242
2243 bool Loader::ShouldBypassCache() const {
2244 if (!mDocument) {
2245 return false;
2246 }
2247 RefPtr<nsILoadGroup> lg = mDocument->GetDocumentLoadGroup();
2248 if (!lg) {
2249 return false;
2250 }
2251 nsLoadFlags flags;
2252 if (NS_FAILED(lg->GetLoadFlags(&flags))) {
2253 return false;
2254 }
2255 return flags & (nsIRequest::LOAD_BYPASS_CACHE |
2256 nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE);
2257 }
2258
2259 void Loader::BlockOnload() {
2260 if (mDocument) {
2261 mDocument->BlockOnload();
2262 }
2263 }
2264
2265 void Loader::UnblockOnload(bool aFireSync) {
2266 if (mDocument) {
2267 mDocument->UnblockOnload(aFireSync);
2268 }
2269 }
2270
2271 already_AddRefed<nsISerialEventTarget> Loader::DispatchTarget() {
2272 nsCOMPtr<nsISerialEventTarget> target;
2273 if (mDocument) {
2274 // If you change this, you may want to change StyleSheet::Replace
2275 target = mDocument->EventTargetFor(TaskCategory::Other);
2276 } else if (mDocGroup) {
2277 target = mDocGroup->EventTargetFor(TaskCategory::Other);
2278 } else {
2279 target = GetMainThreadSerialEventTarget();
2280 }
2281
2282 return target.forget();
2283 }
2284
2285 } // namespace css
2286 } // namespace mozilla