Line data Source code
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 file,
5 : * You can obtain one at http://mozilla.org/MPL/2.0/. */
6 :
7 : #include "BackgroundUtils.h"
8 :
9 : #include "MainThreadUtils.h"
10 : #include "mozilla/Assertions.h"
11 : #include "mozilla/BasePrincipal.h"
12 : #include "mozilla/ipc/PBackgroundSharedTypes.h"
13 : #include "mozilla/ipc/URIUtils.h"
14 : #include "mozilla/net/NeckoChannelParams.h"
15 : #include "ExpandedPrincipal.h"
16 : #include "nsIScriptSecurityManager.h"
17 : #include "nsIURI.h"
18 : #include "nsNetUtil.h"
19 : #include "mozilla/LoadInfo.h"
20 : #include "ContentPrincipal.h"
21 : #include "NullPrincipal.h"
22 : #include "nsContentUtils.h"
23 : #include "nsString.h"
24 : #include "nsTArray.h"
25 : #include "mozilla/nsRedirectHistoryEntry.h"
26 : #include "URIUtils.h"
27 :
28 : namespace mozilla {
29 : namespace net {
30 : class OptionalLoadInfoArgs;
31 : }
32 :
33 : using mozilla::BasePrincipal;
34 : using namespace mozilla::net;
35 :
36 : namespace ipc {
37 :
38 : already_AddRefed<nsIPrincipal>
39 8 : PrincipalInfoToPrincipal(const PrincipalInfo& aPrincipalInfo,
40 : nsresult* aOptionalResult)
41 : {
42 8 : MOZ_ASSERT(NS_IsMainThread());
43 8 : MOZ_ASSERT(aPrincipalInfo.type() != PrincipalInfo::T__None);
44 :
45 : nsresult stackResult;
46 8 : nsresult& rv = aOptionalResult ? *aOptionalResult : stackResult;
47 :
48 : nsCOMPtr<nsIScriptSecurityManager> secMan =
49 16 : nsContentUtils::GetSecurityManager();
50 8 : if (!secMan) {
51 0 : return nullptr;
52 : }
53 :
54 16 : nsCOMPtr<nsIPrincipal> principal;
55 :
56 8 : switch (aPrincipalInfo.type()) {
57 : case PrincipalInfo::TSystemPrincipalInfo: {
58 1 : rv = secMan->GetSystemPrincipal(getter_AddRefs(principal));
59 1 : if (NS_WARN_IF(NS_FAILED(rv))) {
60 0 : return nullptr;
61 : }
62 :
63 1 : return principal.forget();
64 : }
65 :
66 : case PrincipalInfo::TNullPrincipalInfo: {
67 : const NullPrincipalInfo& info =
68 0 : aPrincipalInfo.get_NullPrincipalInfo();
69 :
70 0 : nsCOMPtr<nsIURI> uri;
71 0 : rv = NS_NewURI(getter_AddRefs(uri), info.spec());
72 0 : if (NS_WARN_IF(NS_FAILED(rv))) {
73 0 : return nullptr;
74 : }
75 :
76 0 : principal = NullPrincipal::Create(info.attrs(), uri);
77 0 : return principal.forget();
78 : }
79 :
80 : case PrincipalInfo::TContentPrincipalInfo: {
81 : const ContentPrincipalInfo& info =
82 7 : aPrincipalInfo.get_ContentPrincipalInfo();
83 :
84 14 : nsCOMPtr<nsIURI> uri;
85 7 : rv = NS_NewURI(getter_AddRefs(uri), info.spec());
86 7 : if (NS_WARN_IF(NS_FAILED(rv))) {
87 0 : return nullptr;
88 : }
89 :
90 14 : OriginAttributes attrs;
91 7 : if (info.attrs().mAppId != nsIScriptSecurityManager::UNKNOWN_APP_ID) {
92 7 : attrs = info.attrs();
93 : }
94 7 : principal = BasePrincipal::CreateCodebasePrincipal(uri, attrs);
95 7 : if (NS_WARN_IF(!principal)) {
96 0 : return nullptr;
97 : }
98 :
99 : // When the principal is serialized, the origin is extract from it. This
100 : // can fail, and in case, here we will havea Tvoid_t. If we have a string,
101 : // it must match with what the_new_principal.getOrigin returns.
102 7 : if (info.originNoSuffix().type() == ContentPrincipalInfoOriginNoSuffix::TnsCString) {
103 12 : nsAutoCString originNoSuffix;
104 6 : rv = principal->GetOriginNoSuffix(originNoSuffix);
105 12 : if (NS_WARN_IF(NS_FAILED(rv)) ||
106 6 : !info.originNoSuffix().get_nsCString().Equals(originNoSuffix)) {
107 0 : MOZ_CRASH("If the origin was in the contentPrincipalInfo, it must be available when deserialized");
108 : }
109 : }
110 :
111 7 : return principal.forget();
112 : }
113 :
114 : case PrincipalInfo::TExpandedPrincipalInfo: {
115 0 : const ExpandedPrincipalInfo& info = aPrincipalInfo.get_ExpandedPrincipalInfo();
116 :
117 0 : nsTArray<nsCOMPtr<nsIPrincipal>> whitelist;
118 0 : nsCOMPtr<nsIPrincipal> wlPrincipal;
119 :
120 0 : for (uint32_t i = 0; i < info.whitelist().Length(); i++) {
121 0 : wlPrincipal = PrincipalInfoToPrincipal(info.whitelist()[i], &rv);
122 0 : if (NS_WARN_IF(NS_FAILED(rv))) {
123 0 : return nullptr;
124 : }
125 : // append that principal to the whitelist
126 0 : whitelist.AppendElement(wlPrincipal);
127 : }
128 :
129 : RefPtr<ExpandedPrincipal> expandedPrincipal =
130 0 : ExpandedPrincipal::Create(whitelist, info.attrs());
131 0 : if (!expandedPrincipal) {
132 0 : NS_WARNING("could not instantiate expanded principal");
133 0 : return nullptr;
134 : }
135 :
136 0 : principal = expandedPrincipal;
137 0 : return principal.forget();
138 : }
139 :
140 : default:
141 0 : MOZ_CRASH("Unknown PrincipalInfo type!");
142 : }
143 :
144 : MOZ_CRASH("Should never get here!");
145 : }
146 :
147 : nsresult
148 23 : PrincipalToPrincipalInfo(nsIPrincipal* aPrincipal,
149 : PrincipalInfo* aPrincipalInfo)
150 : {
151 23 : MOZ_ASSERT(NS_IsMainThread());
152 23 : MOZ_ASSERT(aPrincipal);
153 23 : MOZ_ASSERT(aPrincipalInfo);
154 :
155 23 : if (aPrincipal->GetIsNullPrincipal()) {
156 0 : nsCOMPtr<nsIURI> uri;
157 0 : nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
158 0 : if (NS_WARN_IF(NS_FAILED(rv))) {
159 0 : return rv;
160 : }
161 :
162 0 : if (NS_WARN_IF(!uri)) {
163 0 : return NS_ERROR_FAILURE;
164 : }
165 :
166 0 : nsAutoCString spec;
167 0 : rv = uri->GetSpec(spec);
168 0 : if (NS_WARN_IF(NS_FAILED(rv))) {
169 0 : return rv;
170 : }
171 :
172 : *aPrincipalInfo =
173 0 : NullPrincipalInfo(aPrincipal->OriginAttributesRef(), spec);
174 0 : return NS_OK;
175 : }
176 :
177 : nsCOMPtr<nsIScriptSecurityManager> secMan =
178 46 : nsContentUtils::GetSecurityManager();
179 23 : if (!secMan) {
180 0 : return NS_ERROR_FAILURE;
181 : }
182 :
183 : bool isSystemPrincipal;
184 23 : nsresult rv = secMan->IsSystemPrincipal(aPrincipal, &isSystemPrincipal);
185 23 : if (NS_WARN_IF(NS_FAILED(rv))) {
186 0 : return rv;
187 : }
188 :
189 23 : if (isSystemPrincipal) {
190 18 : *aPrincipalInfo = SystemPrincipalInfo();
191 18 : return NS_OK;
192 : }
193 :
194 : // might be an expanded principal
195 : nsCOMPtr<nsIExpandedPrincipal> expanded =
196 10 : do_QueryInterface(aPrincipal);
197 :
198 5 : if (expanded) {
199 0 : nsTArray<PrincipalInfo> whitelistInfo;
200 0 : PrincipalInfo info;
201 :
202 : nsTArray< nsCOMPtr<nsIPrincipal> >* whitelist;
203 0 : MOZ_ALWAYS_SUCCEEDS(expanded->GetWhiteList(&whitelist));
204 :
205 0 : for (uint32_t i = 0; i < whitelist->Length(); i++) {
206 0 : rv = PrincipalToPrincipalInfo((*whitelist)[i], &info);
207 0 : if (NS_WARN_IF(NS_FAILED(rv))) {
208 0 : return rv;
209 : }
210 : // append that spec to the whitelist
211 0 : whitelistInfo.AppendElement(info);
212 : }
213 :
214 : *aPrincipalInfo =
215 0 : ExpandedPrincipalInfo(aPrincipal->OriginAttributesRef(),
216 0 : Move(whitelistInfo));
217 0 : return NS_OK;
218 : }
219 :
220 : // must be a content principal
221 :
222 10 : nsCOMPtr<nsIURI> uri;
223 5 : rv = aPrincipal->GetURI(getter_AddRefs(uri));
224 5 : if (NS_WARN_IF(NS_FAILED(rv))) {
225 0 : return rv;
226 : }
227 :
228 5 : if (NS_WARN_IF(!uri)) {
229 0 : return NS_ERROR_FAILURE;
230 : }
231 :
232 10 : nsAutoCString spec;
233 5 : rv = uri->GetSpec(spec);
234 5 : if (NS_WARN_IF(NS_FAILED(rv))) {
235 0 : return rv;
236 : }
237 :
238 10 : ContentPrincipalInfoOriginNoSuffix infoOriginNoSuffix;
239 :
240 10 : nsCString originNoSuffix;
241 5 : rv = aPrincipal->GetOriginNoSuffix(originNoSuffix);
242 5 : if (NS_WARN_IF(NS_FAILED(rv))) {
243 0 : infoOriginNoSuffix = void_t();
244 : } else {
245 5 : infoOriginNoSuffix = originNoSuffix;
246 : }
247 :
248 10 : *aPrincipalInfo = ContentPrincipalInfo(aPrincipal->OriginAttributesRef(),
249 5 : infoOriginNoSuffix, spec);
250 5 : return NS_OK;
251 : }
252 :
253 : bool
254 0 : IsPincipalInfoPrivate(const PrincipalInfo& aPrincipalInfo)
255 : {
256 0 : if (aPrincipalInfo.type() != ipc::PrincipalInfo::TContentPrincipalInfo) {
257 0 : return false;
258 : }
259 :
260 0 : const ContentPrincipalInfo& info = aPrincipalInfo.get_ContentPrincipalInfo();
261 0 : return !!info.attrs().mPrivateBrowsingId;
262 : }
263 :
264 : already_AddRefed<nsIRedirectHistoryEntry>
265 0 : RHEntryInfoToRHEntry(const RedirectHistoryEntryInfo& aRHEntryInfo)
266 : {
267 : nsresult rv;
268 : nsCOMPtr<nsIPrincipal> principal =
269 0 : PrincipalInfoToPrincipal(aRHEntryInfo.principalInfo(), &rv);
270 0 : if (NS_WARN_IF(NS_FAILED(rv))) {
271 0 : return nullptr;
272 : }
273 :
274 0 : nsCOMPtr<nsIURI> referrerUri = DeserializeURI(aRHEntryInfo.referrerUri());
275 :
276 : nsCOMPtr<nsIRedirectHistoryEntry> entry =
277 0 : new nsRedirectHistoryEntry(principal, referrerUri, aRHEntryInfo.remoteAddress());
278 :
279 0 : return entry.forget();
280 : }
281 :
282 : nsresult
283 0 : RHEntryToRHEntryInfo(nsIRedirectHistoryEntry* aRHEntry,
284 : RedirectHistoryEntryInfo* aRHEntryInfo)
285 : {
286 0 : MOZ_ASSERT(aRHEntry);
287 0 : MOZ_ASSERT(aRHEntryInfo);
288 :
289 : nsresult rv;
290 0 : aRHEntry->GetRemoteAddress(aRHEntryInfo->remoteAddress());
291 :
292 0 : nsCOMPtr<nsIURI> referrerUri;
293 0 : rv = aRHEntry->GetReferrerURI(getter_AddRefs(referrerUri));
294 0 : NS_ENSURE_SUCCESS(rv, rv);
295 0 : SerializeURI(referrerUri, aRHEntryInfo->referrerUri());
296 :
297 0 : nsCOMPtr<nsIPrincipal> principal;
298 0 : rv = aRHEntry->GetPrincipal(getter_AddRefs(principal));
299 0 : NS_ENSURE_SUCCESS(rv, rv);
300 :
301 0 : return PrincipalToPrincipalInfo(principal, &aRHEntryInfo->principalInfo());
302 : }
303 :
304 : nsresult
305 3 : LoadInfoToLoadInfoArgs(nsILoadInfo *aLoadInfo,
306 : OptionalLoadInfoArgs* aOptionalLoadInfoArgs)
307 : {
308 3 : if (!aLoadInfo) {
309 : // if there is no loadInfo, then there is nothing to serialize
310 0 : *aOptionalLoadInfoArgs = void_t();
311 0 : return NS_OK;
312 : }
313 :
314 3 : nsresult rv = NS_OK;
315 6 : OptionalPrincipalInfo loadingPrincipalInfo = mozilla::void_t();
316 3 : if (aLoadInfo->LoadingPrincipal()) {
317 4 : PrincipalInfo loadingPrincipalInfoTemp;
318 2 : rv = PrincipalToPrincipalInfo(aLoadInfo->LoadingPrincipal(),
319 2 : &loadingPrincipalInfoTemp);
320 2 : NS_ENSURE_SUCCESS(rv, rv);
321 2 : loadingPrincipalInfo = loadingPrincipalInfoTemp;
322 : }
323 :
324 6 : PrincipalInfo triggeringPrincipalInfo;
325 3 : rv = PrincipalToPrincipalInfo(aLoadInfo->TriggeringPrincipal(),
326 3 : &triggeringPrincipalInfo);
327 :
328 6 : OptionalPrincipalInfo principalToInheritInfo = mozilla::void_t();
329 3 : if (aLoadInfo->PrincipalToInherit()) {
330 0 : PrincipalInfo principalToInheritInfoTemp;
331 0 : rv = PrincipalToPrincipalInfo(aLoadInfo->PrincipalToInherit(),
332 0 : &principalToInheritInfoTemp);
333 0 : NS_ENSURE_SUCCESS(rv, rv);
334 0 : principalToInheritInfo = principalToInheritInfoTemp;
335 : }
336 :
337 6 : OptionalPrincipalInfo sandboxedLoadingPrincipalInfo = mozilla::void_t();
338 3 : if (aLoadInfo->GetLoadingSandboxed()) {
339 0 : PrincipalInfo sandboxedLoadingPrincipalInfoTemp;
340 0 : nsCOMPtr<nsIPrincipal> sandboxedLoadingPrincipal;
341 0 : rv = aLoadInfo->GetSandboxedLoadingPrincipal(
342 0 : getter_AddRefs(sandboxedLoadingPrincipal));
343 0 : NS_ENSURE_SUCCESS(rv, rv);
344 0 : rv = PrincipalToPrincipalInfo(sandboxedLoadingPrincipal,
345 0 : &sandboxedLoadingPrincipalInfoTemp);
346 0 : NS_ENSURE_SUCCESS(rv, rv);
347 0 : sandboxedLoadingPrincipalInfo = sandboxedLoadingPrincipalInfoTemp;
348 : }
349 :
350 6 : OptionalURIParams optionalResultPrincipalURI = mozilla::void_t();
351 6 : nsCOMPtr<nsIURI> resultPrincipalURI;
352 3 : Unused << aLoadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
353 3 : if (resultPrincipalURI) {
354 0 : SerializeURI(resultPrincipalURI, optionalResultPrincipalURI);
355 : }
356 :
357 6 : nsTArray<RedirectHistoryEntryInfo> redirectChainIncludingInternalRedirects;
358 3 : for (const nsCOMPtr<nsIRedirectHistoryEntry>& redirectEntry :
359 3 : aLoadInfo->RedirectChainIncludingInternalRedirects()) {
360 0 : RedirectHistoryEntryInfo* entry = redirectChainIncludingInternalRedirects.AppendElement();
361 0 : rv = RHEntryToRHEntryInfo(redirectEntry, entry);
362 0 : NS_ENSURE_SUCCESS(rv, rv);
363 : }
364 :
365 6 : nsTArray<RedirectHistoryEntryInfo> redirectChain;
366 3 : for (const nsCOMPtr<nsIRedirectHistoryEntry>& redirectEntry :
367 3 : aLoadInfo->RedirectChain()) {
368 0 : RedirectHistoryEntryInfo* entry = redirectChain.AppendElement();
369 0 : rv = RHEntryToRHEntryInfo(redirectEntry, entry);
370 0 : NS_ENSURE_SUCCESS(rv, rv);
371 : }
372 :
373 : *aOptionalLoadInfoArgs =
374 9 : LoadInfoArgs(
375 : loadingPrincipalInfo,
376 : triggeringPrincipalInfo,
377 : principalToInheritInfo,
378 : sandboxedLoadingPrincipalInfo,
379 : optionalResultPrincipalURI,
380 6 : aLoadInfo->GetSecurityFlags(),
381 6 : aLoadInfo->InternalContentPolicyType(),
382 6 : static_cast<uint32_t>(aLoadInfo->GetTainting()),
383 6 : aLoadInfo->GetUpgradeInsecureRequests(),
384 6 : aLoadInfo->GetVerifySignedContent(),
385 6 : aLoadInfo->GetEnforceSRI(),
386 6 : aLoadInfo->GetForceInheritPrincipalDropped(),
387 6 : aLoadInfo->GetInnerWindowID(),
388 6 : aLoadInfo->GetOuterWindowID(),
389 6 : aLoadInfo->GetParentOuterWindowID(),
390 6 : aLoadInfo->GetFrameOuterWindowID(),
391 6 : aLoadInfo->GetEnforceSecurity(),
392 6 : aLoadInfo->GetInitialSecurityCheckDone(),
393 6 : aLoadInfo->GetIsInThirdPartyContext(),
394 6 : aLoadInfo->GetOriginAttributes(),
395 : redirectChainIncludingInternalRedirects,
396 : redirectChain,
397 3 : aLoadInfo->CorsUnsafeHeaders(),
398 6 : aLoadInfo->GetForcePreflight(),
399 6 : aLoadInfo->GetIsPreflight(),
400 6 : aLoadInfo->GetForceHSTSPriming(),
401 6 : aLoadInfo->GetMixedContentWouldBlock(),
402 6 : aLoadInfo->GetIsHSTSPriming(),
403 6 : aLoadInfo->GetIsHSTSPrimingUpgrade()
404 3 : );
405 :
406 3 : return NS_OK;
407 : }
408 :
409 : nsresult
410 3 : LoadInfoArgsToLoadInfo(const OptionalLoadInfoArgs& aOptionalLoadInfoArgs,
411 : nsILoadInfo** outLoadInfo)
412 : {
413 3 : if (aOptionalLoadInfoArgs.type() == OptionalLoadInfoArgs::Tvoid_t) {
414 0 : *outLoadInfo = nullptr;
415 0 : return NS_OK;
416 : }
417 :
418 : const LoadInfoArgs& loadInfoArgs =
419 3 : aOptionalLoadInfoArgs.get_LoadInfoArgs();
420 :
421 3 : nsresult rv = NS_OK;
422 6 : nsCOMPtr<nsIPrincipal> loadingPrincipal;
423 3 : if (loadInfoArgs.requestingPrincipalInfo().type() != OptionalPrincipalInfo::Tvoid_t) {
424 2 : loadingPrincipal = PrincipalInfoToPrincipal(loadInfoArgs.requestingPrincipalInfo(), &rv);
425 2 : NS_ENSURE_SUCCESS(rv, rv);
426 : }
427 :
428 3 : NS_ENSURE_SUCCESS(rv, rv);
429 : nsCOMPtr<nsIPrincipal> triggeringPrincipal =
430 6 : PrincipalInfoToPrincipal(loadInfoArgs.triggeringPrincipalInfo(), &rv);
431 3 : NS_ENSURE_SUCCESS(rv, rv);
432 :
433 6 : nsCOMPtr<nsIPrincipal> principalToInherit;
434 3 : if (loadInfoArgs.principalToInheritInfo().type() != OptionalPrincipalInfo::Tvoid_t) {
435 0 : principalToInherit = PrincipalInfoToPrincipal(loadInfoArgs.principalToInheritInfo(), &rv);
436 0 : NS_ENSURE_SUCCESS(rv, rv);
437 : }
438 :
439 6 : nsCOMPtr<nsIPrincipal> sandboxedLoadingPrincipal;
440 3 : if (loadInfoArgs.sandboxedLoadingPrincipalInfo().type() != OptionalPrincipalInfo::Tvoid_t) {
441 : sandboxedLoadingPrincipal =
442 0 : PrincipalInfoToPrincipal(loadInfoArgs.sandboxedLoadingPrincipalInfo(), &rv);
443 0 : NS_ENSURE_SUCCESS(rv, rv);
444 : }
445 :
446 6 : nsCOMPtr<nsIURI> resultPrincipalURI;
447 3 : if (loadInfoArgs.resultPrincipalURI().type() != OptionalURIParams::Tvoid_t) {
448 0 : resultPrincipalURI = DeserializeURI(loadInfoArgs.resultPrincipalURI());
449 0 : NS_ENSURE_TRUE(resultPrincipalURI, NS_ERROR_UNEXPECTED);
450 : }
451 :
452 6 : RedirectHistoryArray redirectChainIncludingInternalRedirects;
453 3 : for (const RedirectHistoryEntryInfo& entryInfo :
454 3 : loadInfoArgs.redirectChainIncludingInternalRedirects()) {
455 : nsCOMPtr<nsIRedirectHistoryEntry> redirectHistoryEntry =
456 0 : RHEntryInfoToRHEntry(entryInfo);
457 0 : NS_ENSURE_SUCCESS(rv, rv);
458 0 : redirectChainIncludingInternalRedirects.AppendElement(redirectHistoryEntry.forget());
459 : }
460 :
461 6 : RedirectHistoryArray redirectChain;
462 3 : for (const RedirectHistoryEntryInfo& entryInfo : loadInfoArgs.redirectChain()) {
463 : nsCOMPtr<nsIRedirectHistoryEntry> redirectHistoryEntry =
464 0 : RHEntryInfoToRHEntry(entryInfo);
465 0 : NS_ENSURE_SUCCESS(rv, rv);
466 0 : redirectChain.AppendElement(redirectHistoryEntry.forget());
467 : }
468 :
469 : nsCOMPtr<nsILoadInfo> loadInfo =
470 : new mozilla::LoadInfo(loadingPrincipal,
471 : triggeringPrincipal,
472 : principalToInherit,
473 : sandboxedLoadingPrincipal,
474 : resultPrincipalURI,
475 3 : loadInfoArgs.securityFlags(),
476 3 : loadInfoArgs.contentPolicyType(),
477 3 : static_cast<LoadTainting>(loadInfoArgs.tainting()),
478 3 : loadInfoArgs.upgradeInsecureRequests(),
479 3 : loadInfoArgs.verifySignedContent(),
480 3 : loadInfoArgs.enforceSRI(),
481 3 : loadInfoArgs.forceInheritPrincipalDropped(),
482 3 : loadInfoArgs.innerWindowID(),
483 3 : loadInfoArgs.outerWindowID(),
484 3 : loadInfoArgs.parentOuterWindowID(),
485 3 : loadInfoArgs.frameOuterWindowID(),
486 3 : loadInfoArgs.enforceSecurity(),
487 3 : loadInfoArgs.initialSecurityCheckDone(),
488 3 : loadInfoArgs.isInThirdPartyContext(),
489 : loadInfoArgs.originAttributes(),
490 : redirectChainIncludingInternalRedirects,
491 : redirectChain,
492 : loadInfoArgs.corsUnsafeHeaders(),
493 3 : loadInfoArgs.forcePreflight(),
494 3 : loadInfoArgs.isPreflight(),
495 3 : loadInfoArgs.forceHSTSPriming(),
496 3 : loadInfoArgs.mixedContentWouldBlock(),
497 3 : loadInfoArgs.isHSTSPriming(),
498 3 : loadInfoArgs.isHSTSPrimingUpgrade()
499 12 : );
500 :
501 3 : loadInfo.forget(outLoadInfo);
502 3 : return NS_OK;
503 : }
504 :
505 : } // namespace ipc
506 : } // namespace mozilla
|
