forked from Floorp-Projects/Floorp
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathnsDocShell.h
1268 lines (1074 loc) · 51.3 KB
/
nsDocShell.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsDocShell_h__
#define nsDocShell_h__
#include <utility>
#include "GeckoProfiler.h"
#include "Units.h"
#include "jsapi.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/HalScreenConfiguration.h"
#include "mozilla/LinkedList.h"
#include "mozilla/Maybe.h"
#include "mozilla/ObservedDocShell.h"
#include "mozilla/ScrollbarPreferences.h"
#include "mozilla/StaticPrefs_browser.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/TimelineConsumers.h"
#include "mozilla/TimelineMarker.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/WeakPtr.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/ChildSHistory.h"
#include "mozilla/dom/ProfileTimelineMarkerBinding.h"
#include "mozilla/dom/WindowProxyHolder.h"
#include "mozilla/gfx/Matrix.h"
#include "nsCOMPtr.h"
#include "nsCRT.h"
#include "nsCharsetSource.h"
#include "nsContentPolicyUtils.h"
#include "nsContentUtils.h"
#include "nsDocLoader.h"
#include "nsIAuthPromptProvider.h"
#include "nsIBaseWindow.h"
#include "nsIDeprecationWarner.h"
#include "nsIDocShell.h"
#include "nsIDocShellTreeItem.h"
#include "nsIInterfaceRequestor.h"
#include "nsILoadContext.h"
#include "nsILoadURIDelegate.h"
#include "nsINetworkInterceptController.h"
#include "nsIRefreshURI.h"
#include "nsIWebNavigation.h"
#include "nsIWebPageDescriptor.h"
#include "nsIWebProgressListener.h"
#include "nsPoint.h" // mCurrent/mDefaultScrollbarPreferences
#include "nsRect.h"
#include "nsString.h"
#include "nsThreadUtils.h"
#include "prtime.h"
// Interfaces Needed
namespace mozilla {
class Encoding;
class HTMLEditor;
enum class TaskCategory;
namespace dom {
class ClientInfo;
class ClientSource;
class EventTarget;
class SessionHistoryInfo;
} // namespace dom
namespace net {
class LoadInfo;
class DocumentLoadListener;
} // namespace net
} // namespace mozilla
class nsIContentViewer;
class nsIController;
class nsIDocShellTreeOwner;
class nsIHttpChannel;
class nsIMutableArray;
class nsIPrompt;
class nsIScrollableFrame;
class nsISecureBrowserUI;
class nsISHistory;
class nsIStringBundle;
class nsIURIFixup;
class nsIURIFixupInfo;
class nsIURILoader;
class nsIWebBrowserFind;
class nsIWidget;
class nsIReferrerInfo;
class nsCommandManager;
class nsDocShell;
class nsDocShellEditorData;
class nsDOMNavigationTiming;
class nsDSURIContentListener;
class nsGlobalWindowInner;
class nsGlobalWindowOuter;
class FramingChecker;
class OnLinkClickEvent;
/* internally used ViewMode types */
enum ViewMode { viewNormal = 0x0, viewSource = 0x1 };
enum eCharsetReloadState {
eCharsetReloadInit,
eCharsetReloadRequested,
eCharsetReloadStopOrigional
};
class nsDocShell final : public nsDocLoader,
public nsIDocShell,
public nsIWebNavigation,
public nsIBaseWindow,
public nsIRefreshURI,
public nsIWebProgressListener,
public nsIWebPageDescriptor,
public nsIAuthPromptProvider,
public nsILoadContext,
public nsINetworkInterceptController,
public nsIDeprecationWarner,
public mozilla::SupportsWeakPtr<nsDocShell> {
public:
enum InternalLoad : uint32_t {
INTERNAL_LOAD_FLAGS_NONE = 0x0,
INTERNAL_LOAD_FLAGS_INHERIT_PRINCIPAL = 0x1,
INTERNAL_LOAD_FLAGS_DONT_SEND_REFERRER = 0x2,
INTERNAL_LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP = 0x4,
// This flag marks the first load in this object
// @see nsIWebNavigation::LOAD_FLAGS_FIRST_LOAD
INTERNAL_LOAD_FLAGS_FIRST_LOAD = 0x8,
// The set of flags that should not be set before calling into
// nsDocShell::LoadURI and other nsDocShell loading functions.
INTERNAL_LOAD_FLAGS_LOADURI_SETUP_FLAGS = 0xf,
INTERNAL_LOAD_FLAGS_BYPASS_CLASSIFIER = 0x10,
INTERNAL_LOAD_FLAGS_FORCE_ALLOW_COOKIES = 0x20,
// Whether the load should be treated as srcdoc load, rather than a URI one.
INTERNAL_LOAD_FLAGS_IS_SRCDOC = 0x40,
// Whether this is the load of a frame's original src attribute
INTERNAL_LOAD_FLAGS_ORIGINAL_FRAME_SRC = 0x80,
INTERNAL_LOAD_FLAGS_NO_OPENER = 0x100,
// Whether a top-level data URI navigation is allowed for that load
INTERNAL_LOAD_FLAGS_FORCE_ALLOW_DATA_URI = 0x200,
// Whether the load should go through LoadURIDelegate.
INTERNAL_LOAD_FLAGS_BYPASS_LOAD_URI_DELEGATE = 0x2000,
};
// Event type dispatched by RestorePresentation
class RestorePresentationEvent : public mozilla::Runnable {
public:
NS_DECL_NSIRUNNABLE
explicit RestorePresentationEvent(nsDocShell* aDs)
: mozilla::Runnable("nsDocShell::RestorePresentationEvent"),
mDocShell(aDs) {}
void Revoke() { mDocShell = nullptr; }
private:
RefPtr<nsDocShell> mDocShell;
};
class InterfaceRequestorProxy : public nsIInterfaceRequestor {
public:
explicit InterfaceRequestorProxy(nsIInterfaceRequestor* aRequestor);
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINTERFACEREQUESTOR
private:
virtual ~InterfaceRequestorProxy();
InterfaceRequestorProxy() = default;
nsWeakPtr mWeakPtr;
};
MOZ_DECLARE_WEAKREFERENCE_TYPENAME(nsDocShell)
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsDocShell, nsDocLoader)
NS_DECL_NSIDOCSHELL
NS_DECL_NSIDOCSHELLTREEITEM
NS_DECL_NSIWEBNAVIGATION
NS_DECL_NSIBASEWINDOW
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSIWEBPROGRESSLISTENER
NS_DECL_NSIREFRESHURI
NS_DECL_NSIWEBPAGEDESCRIPTOR
NS_DECL_NSIAUTHPROMPTPROVIDER
NS_DECL_NSINETWORKINTERCEPTCONTROLLER
NS_DECL_NSIDEPRECATIONWARNER
// Create a new nsDocShell object.
static already_AddRefed<nsDocShell> Create(
mozilla::dom::BrowsingContext* aBrowsingContext,
uint64_t aContentWindowID = 0);
bool Initialize();
NS_IMETHOD Stop() override {
// Need this here because otherwise nsIWebNavigation::Stop
// overrides the docloader's Stop()
return nsDocLoader::Stop();
}
mozilla::ScrollbarPreference ScrollbarPreference() const {
return mScrollbarPref;
}
void SetScrollbarPreference(mozilla::ScrollbarPreference);
/*
* The size, in CSS pixels, of the margins for the <body> of an HTML document
* in this docshell; used to implement the marginwidth attribute on HTML
* <frame>/<iframe> elements. A value smaller than zero indicates that the
* attribute was not set.
*/
const mozilla::CSSIntSize& GetFrameMargins() const { return mFrameMargins; }
bool UpdateFrameMargins(const mozilla::CSSIntSize& aMargins) {
if (mFrameMargins == aMargins) {
return false;
}
mFrameMargins = aMargins;
return true;
}
/**
* Process a click on a link.
*
* @param aContent the content object used for triggering the link.
* @param aURI a URI object that defines the destination for the link
* @param aTargetSpec indicates where the link is targeted (may be an empty
* string)
* @param aFileName non-null when the link should be downloaded as the given
* file
* @param aPostDataStream the POST data to send
* @param aHeadersDataStream ??? (only used for plugins)
* @param aIsTrusted false if the triggerer is an untrusted DOM event.
* @param aTriggeringPrincipal, if not passed explicitly we fall back to
* the document's principal.
* @param aCsp, the CSP to be used for the load, that is the CSP of the
* entity responsible for causing the load to occur. Most likely
* this is the CSP of the document that started the load. In case
* aCsp was not passed explicitly we fall back to using
* aContent's document's CSP if that document holds any.
*/
nsresult OnLinkClick(nsIContent* aContent, nsIURI* aURI,
const nsAString& aTargetSpec, const nsAString& aFileName,
nsIInputStream* aPostDataStream,
nsIInputStream* aHeadersDataStream,
bool aIsUserTriggered, bool aIsTrusted,
nsIPrincipal* aTriggeringPrincipal,
nsIContentSecurityPolicy* aCsp);
/**
* Process a click on a link.
*
* Works the same as OnLinkClick() except it happens immediately rather than
* through an event.
*
* @param aContent the content object used for triggering the link.
* @param aDocShellLoadState the extended load info for this load.
* @param aNoOpenerImplied if the link implies "noopener"
* @param aTriggeringPrincipal, if not passed explicitly we fall back to
* the document's principal.
*/
nsresult OnLinkClickSync(nsIContent* aContent,
nsDocShellLoadState* aLoadState,
bool aNoOpenerImplied,
nsIPrincipal* aTriggeringPrincipal);
/**
* Process a mouse-over a link.
*
* @param aContent the linked content.
* @param aURI an URI object that defines the destination for the link
* @param aTargetSpec indicates where the link is targeted (it may be an empty
* string)
*/
nsresult OnOverLink(nsIContent* aContent, nsIURI* aURI,
const nsAString& aTargetSpec);
/**
* Process the mouse leaving a link.
*/
nsresult OnLeaveLink();
// Don't use NS_DECL_NSILOADCONTEXT because some of nsILoadContext's methods
// are shared with nsIDocShell and can't be declared twice.
NS_IMETHOD GetAssociatedWindow(mozIDOMWindowProxy**) override;
NS_IMETHOD GetTopWindow(mozIDOMWindowProxy**) override;
NS_IMETHOD GetTopFrameElement(mozilla::dom::Element**) override;
NS_IMETHOD GetIsContent(bool*) override;
NS_IMETHOD GetUsePrivateBrowsing(bool*) override;
NS_IMETHOD SetUsePrivateBrowsing(bool) override;
NS_IMETHOD SetPrivateBrowsing(bool) override;
NS_IMETHOD GetUseRemoteTabs(bool*) override;
NS_IMETHOD SetRemoteTabs(bool) override;
NS_IMETHOD GetUseRemoteSubframes(bool*) override;
NS_IMETHOD SetRemoteSubframes(bool) override;
NS_IMETHOD GetScriptableOriginAttributes(
JSContext*, JS::MutableHandle<JS::Value>) override;
NS_IMETHOD_(void)
GetOriginAttributes(mozilla::OriginAttributes& aAttrs) override;
// Restores a cached presentation from history (mLSHE).
// This method swaps out the content viewer and simulates loads for
// subframes. It then simulates the completion of the toplevel load.
nsresult RestoreFromHistory();
// Perform a URI load from a refresh timer. This is just like the
// ForceRefreshURI method on nsIRefreshURI, but makes sure to take
// the timer involved out of mRefreshURIList if it's there.
// aTimer must not be null.
nsresult ForceRefreshURIFromTimer(nsIURI* aURI, nsIPrincipal* aPrincipal,
int32_t aDelay, bool aMetaRefresh,
nsITimer* aTimer);
// We need dummy OnLocationChange in some cases to update the UI without
// updating security info.
void FireDummyOnLocationChange() {
FireOnLocationChange(this, nullptr, mCurrentURI,
LOCATION_CHANGE_SAME_DOCUMENT);
}
// This function is created exclusively for dom.background_loading_iframe is
// set. As soon as the current DocShell knows itself can be treated as
// background loading, it triggers the parent docshell to see if the parent
// document can fire load event earlier.
void TriggerParentCheckDocShellIsEmpty();
nsresult HistoryEntryRemoved(int32_t aIndex);
// Notify Scroll observers when an async panning/zooming transform
// has started being applied
MOZ_CAN_RUN_SCRIPT_BOUNDARY
void NotifyAsyncPanZoomStarted();
// Notify Scroll observers when an async panning/zooming transform
// is no longer applied
MOZ_CAN_RUN_SCRIPT_BOUNDARY
void NotifyAsyncPanZoomStopped();
void SetInFrameSwap(bool aInSwap) { mInFrameSwap = aInSwap; }
bool InFrameSwap();
const mozilla::Encoding* GetForcedCharset() { return mForcedCharset; }
mozilla::HTMLEditor* GetHTMLEditorInternal();
nsresult SetHTMLEditorInternal(mozilla::HTMLEditor* aHTMLEditor);
// Handle page navigation due to charset changes
nsresult CharsetChangeReloadDocument(const char* aCharset = nullptr,
int32_t aSource = kCharsetUninitialized);
nsresult CharsetChangeStopDocumentLoad();
nsDOMNavigationTiming* GetNavigationTiming() const;
nsresult SetOriginAttributes(const mozilla::OriginAttributes& aAttrs);
const mozilla::OriginAttributes& GetOriginAttributes() {
return mBrowsingContext->OriginAttributesRef();
}
// Determine whether this docshell corresponds to the given history entry,
// via having a pointer to it in mOSHE or mLSHE.
bool HasHistoryEntry(nsISHEntry* aEntry) const {
return aEntry && (aEntry == mOSHE || aEntry == mLSHE);
}
// Update any pointers (mOSHE or mLSHE) to aOldEntry to point to aNewEntry
void SwapHistoryEntries(nsISHEntry* aOldEntry, nsISHEntry* aNewEntry);
mozilla::gfx::Matrix5x4* GetColorMatrix() { return mColorMatrix.get(); }
static bool SandboxFlagsImplyCookies(const uint32_t& aSandboxFlags);
// Tell the favicon service that aNewURI has the same favicon as aOldURI.
static void CopyFavicon(nsIURI* aOldURI, nsIURI* aNewURI,
nsIPrincipal* aLoadingPrincipal,
bool aInPrivateBrowsing);
static nsDocShell* Cast(nsIDocShell* aDocShell) {
return static_cast<nsDocShell*>(aDocShell);
}
static bool CanLoadInParentProcess(nsIURI* aURI);
// Returns true if the current load is a force reload (started by holding
// shift while triggering reload)
bool IsForceReloading();
mozilla::dom::WindowProxyHolder GetWindowProxy() {
EnsureScriptEnvironment();
return mozilla::dom::WindowProxyHolder(mBrowsingContext);
}
/**
* Loads the given URI. See comments on nsDocShellLoadState members for more
* information on information used. aDocShell and aRequest come from
* onLinkClickSync, which is triggered during form submission.
*/
MOZ_CAN_RUN_SCRIPT_BOUNDARY
nsresult InternalLoad(nsDocShellLoadState* aLoadState);
// Clear the document's storage access flag if needed.
void MaybeClearStorageAccessFlag();
void SetWillChangeProcess() { mWillChangeProcess = true; }
// Create a content viewer within this nsDocShell for the given
// `WindowGlobalChild` actor.
nsresult CreateContentViewerForActor(
mozilla::dom::WindowGlobalChild* aWindowActor);
// Creates a real network channel (not a DocumentChannel) using the specified
// parameters.
// Used by nsDocShell when not using DocumentChannel, by DocumentLoadListener
// (parent-process DocumentChannel), and by DocumentChannelChild/ContentChild
// to transfer the resulting channel into the final process.
static nsresult CreateRealChannelForDocument(
nsIChannel** aChannel, nsIURI* aURI, nsILoadInfo* aLoadInfo,
nsIInterfaceRequestor* aCallbacks, nsLoadFlags aLoadFlags,
const nsAString& aSrcdoc, nsIURI* aBaseURI);
// Creates a real (not DocumentChannel) channel, and configures it using the
// supplied nsDocShellLoadState.
// Configuration options here are ones that should be applied to only the
// real channel, especially ones that need to QI to channel subclasses.
static bool CreateAndConfigureRealChannelForLoadState(
mozilla::dom::BrowsingContext* aBrowsingContext,
nsDocShellLoadState* aLoadState, mozilla::net::LoadInfo* aLoadInfo,
nsIInterfaceRequestor* aCallbacks, nsDocShell* aDocShell,
const mozilla::OriginAttributes& aOriginAttributes,
nsLoadFlags aLoadFlags, uint32_t aCacheKey, nsresult& rv,
nsIChannel** aChannel);
static already_AddRefed<nsIURI> AttemptURIFixup(
nsIChannel* aChannel, nsresult aStatus,
const mozilla::Maybe<nsCString>& aOriginalURIString, uint32_t aLoadType,
bool aIsTopFrame, bool aAllowKeywordFixup, bool aUsePrivateBrowsing,
bool aNotifyKeywordSearchLoading = false,
nsIInputStream** aNewPostData = nullptr);
static already_AddRefed<nsIURI> MaybeFixBadCertDomainErrorURI(
nsIChannel* aChannel, nsIURI* aUrl);
// Takes aStatus and filters out results that should not display
// an error page.
// If this returns a failed result, then we should display an error
// page with that result.
// aSkippedUnknownProtocolNavigation will be set to true if we chose
// to skip displaying an error page for an NS_ERROR_UNKNOWN_PROTOCOL
// navigation.
static nsresult FilterStatusForErrorPage(
nsresult aStatus, nsIChannel* aChannel, uint32_t aLoadType,
bool aIsTopFrame, bool aUseErrorPages, bool aIsInitialDocument,
bool* aSkippedUnknownProtocolNavigation = nullptr);
// Notify consumers of a search being loaded through the observer service:
static void MaybeNotifyKeywordSearchLoading(const nsString& aProvider,
const nsString& aKeyword);
nsDocShell* GetInProcessChildAt(int32_t aIndex);
static bool ShouldAddURIVisit(nsIChannel* aChannel);
/**
* Helper function that finds the last URI and its transition flags for a
* channel.
*
* This method first checks the channel's property bag to see if previous
* info has been saved. If not, it gives back the referrer of the channel.
*
* @param aChannel
* The channel we are transitioning to
* @param aURI
* Output parameter with the previous URI, not addref'd
* @param aChannelRedirectFlags
* If a redirect, output parameter with the previous redirect flags
* from nsIChannelEventSink
*/
static void ExtractLastVisit(nsIChannel* aChannel, nsIURI** aURI,
uint32_t* aChannelRedirectFlags);
bool HasContentViewer() const { return !!mContentViewer; }
static uint32_t ComputeURILoaderFlags(
mozilla::dom::BrowsingContext* aBrowsingContext, uint32_t aLoadType);
void SetLoadingSessionHistoryInfo(
const mozilla::dom::SessionHistoryInfo& aInfo);
private: // member functions
friend class nsDSURIContentListener;
friend class FramingChecker;
friend class OnLinkClickEvent;
friend class nsIDocShell;
friend class mozilla::dom::BrowsingContext;
friend class mozilla::net::DocumentLoadListener;
friend class nsGlobalWindowOuter;
// It is necessary to allow adding a timeline marker wherever a docshell
// instance is available. This operation happens frequently and needs to
// be very fast, so instead of using a Map or having to search for some
// docshell-specific markers storage, a pointer to an `ObservedDocShell` is
// is stored on docshells directly.
friend void mozilla::TimelineConsumers::AddConsumer(nsDocShell*);
friend void mozilla::TimelineConsumers::RemoveConsumer(nsDocShell*);
friend void mozilla::TimelineConsumers::AddMarkerForDocShell(
nsDocShell*, const char*, MarkerTracingType, MarkerStackRequest);
friend void mozilla::TimelineConsumers::AddMarkerForDocShell(
nsDocShell*, const char*, const TimeStamp&, MarkerTracingType,
MarkerStackRequest);
friend void mozilla::TimelineConsumers::AddMarkerForDocShell(
nsDocShell*, UniquePtr<AbstractTimelineMarker>&&);
friend void mozilla::TimelineConsumers::PopMarkers(
nsDocShell*, JSContext*, nsTArray<dom::ProfileTimelineMarker>&);
nsDocShell(mozilla::dom::BrowsingContext* aBrowsingContext,
uint64_t aContentWindowID);
// Security check to prevent frameset spoofing. See comments at
// implementation site.
static bool ValidateOrigin(mozilla::dom::BrowsingContext* aOrigin,
mozilla::dom::BrowsingContext* aTarget);
static inline uint32_t PRTimeToSeconds(PRTime aTimeUsec) {
return uint32_t(aTimeUsec / PR_USEC_PER_SEC);
}
virtual ~nsDocShell();
//
// nsDocLoader
//
virtual void DestroyChildren() override;
// Overridden from nsDocLoader, this provides more information than the
// normal OnStateChange with flags STATE_REDIRECTING
virtual void OnRedirectStateChange(nsIChannel* aOldChannel,
nsIChannel* aNewChannel,
uint32_t aRedirectFlags,
uint32_t aStateFlags) override;
// Override the parent setter from nsDocLoader
virtual nsresult SetDocLoaderParent(nsDocLoader* aLoader) override;
//
// Content Viewer Management
//
nsresult EnsureContentViewer();
// aPrincipal can be passed in if the caller wants. If null is
// passed in, the about:blank principal will end up being used.
// aCSP, if any, will be used for the new about:blank load.
nsresult CreateAboutBlankContentViewer(
nsIPrincipal* aPrincipal, nsIPrincipal* aPartitionedPrincipal,
nsIContentSecurityPolicy* aCSP, nsIURI* aBaseURI,
const Maybe<nsILoadInfo::CrossOriginEmbedderPolicy>& aCOEP =
mozilla::Nothing(),
bool aTryToSaveOldPresentation = true, bool aCheckPermitUnload = true,
mozilla::dom::WindowGlobalChild* aActor = nullptr);
nsresult CreateContentViewer(const nsACString& aContentType,
nsIRequest* aRequest,
nsIStreamListener** aContentHandler);
nsresult NewContentViewerObj(const nsACString& aContentType,
nsIRequest* aRequest, nsILoadGroup* aLoadGroup,
nsIStreamListener** aContentHandler,
nsIContentViewer** aViewer);
already_AddRefed<nsILoadURIDelegate> GetLoadURIDelegate();
nsresult SetupNewViewer(
nsIContentViewer* aNewViewer,
mozilla::dom::WindowGlobalChild* aWindowActor = nullptr);
//
// Session History
//
bool ShouldAddToSessionHistory(nsIURI* aURI, nsIChannel* aChannel);
// Either aChannel or aOwner must be null. If aChannel is
// present, the owner should be gotten from it.
// If aCloneChildren is true, then our current session history's
// children will be cloned onto the new entry. This should be
// used when we aren't actually changing the document while adding
// the new session history entry.
// aCsp is the CSP to be used for the load. That is *not* the CSP
// that will be applied to subresource loads within that document
// but the CSP for the document load itself. E.g. if that CSP
// includes upgrade-insecure-requests, then the new top-level load
// will be upgraded to HTTPS.
nsresult AddToSessionHistory(nsIURI* aURI, nsIChannel* aChannel,
nsIPrincipal* aTriggeringPrincipal,
nsIPrincipal* aPrincipalToInherit,
nsIPrincipal* aPartitionedPrincipalToInherit,
nsIContentSecurityPolicy* aCsp,
bool aCloneChildren, nsISHEntry** aNewEntry);
nsresult AddChildSHEntryToParent(nsISHEntry* aNewEntry, int32_t aChildOffset,
bool aCloneChildren);
// Call this method to swap in a new history entry to m[OL]SHE, rather than
// setting it directly. This completes the navigation in all docshells
// in the case of a subframe navigation.
// Returns old mOSHE/mLSHE.
already_AddRefed<nsISHEntry> SetHistoryEntry(nsCOMPtr<nsISHEntry>* aPtr,
nsISHEntry* aEntry);
// This method calls SetHistoryEntry and updates mOSHE and mLSHE in BC to be
// the same as in docshell
void SetHistoryEntryAndUpdateBC(const Maybe<nsISHEntry*>& aLSHE,
const Maybe<nsISHEntry*>& aOSHE);
mozilla::dom::ChildSHistory* GetSessionHistory() {
return mBrowsingContext->GetChildSessionHistory();
}
static nsresult ReloadDocument(
nsDocShell* aDocShell, mozilla::dom::Document* aDocument,
uint32_t aLoadType, mozilla::dom::BrowsingContext* aBrowsingContext,
nsIURI* aCurrentURI, nsIReferrerInfo* aReferrerInfo);
//
// URI Load
//
// Actually open a channel and perform a URI load. Callers need to pass a
// non-null aLoadState->TriggeringPrincipal() which initiated the URI load.
// Please note that the TriggeringPrincipal will be used for performing
// security checks. If aLoadState->URI() is provided by the web, then please
// do not pass a SystemPrincipal as the triggeringPrincipal. If
// aLoadState()->PrincipalToInherit is null, then no inheritance of any sort
// will happen and the load will get a principal based on the URI being
// loaded. If the Srcdoc flag is set (INTERNAL_LOAD_FLAGS_IS_SRCDOC), the load
// will be considered as a srcdoc load, and the contents of Srcdoc will be
// loaded instead of the URI. aLoadState->OriginalURI() will be set as the
// originalURI on the channel that does the load. If OriginalURI is null, URI
// will be set as the originalURI. If LoadReplace is true, LOAD_REPLACE flag
// will be set on the nsIChannel.
nsresult DoURILoad(nsDocShellLoadState* aLoadState, nsIRequest** aRequest);
static nsresult AddHeadersToChannel(nsIInputStream* aHeadersData,
nsIChannel* aChannel);
nsresult OpenInitializedChannel(nsIChannel* aChannel,
nsIURILoader* aURILoader,
uint32_t aOpenFlags);
nsresult OpenRedirectedChannel(nsDocShellLoadState* aLoadState);
void UpdateMixedContentChannelForNewLoad(nsIChannel* aChannel);
MOZ_CAN_RUN_SCRIPT
nsresult ScrollToAnchor(bool aCurHasRef, bool aNewHasRef,
nsACString& aNewHash, uint32_t aLoadType);
// Returns true if would have called FireOnLocationChange,
// but did not because aFireOnLocationChange was false on entry.
// In this case it is the caller's responsibility to ensure
// FireOnLocationChange is called.
// In all other cases false is returned.
// Either aChannel or aTriggeringPrincipal must be null. If aChannel is
// present, the owner should be gotten from it.
// If OnNewURI calls AddToSessionHistory, it will pass its
// aCloneSHChildren argument as aCloneChildren.
// aCsp is the CSP to be used for the load. That is *not* the CSP
// that will be applied to subresource loads within that document
// but the CSP for the document load itself. E.g. if that CSP
// includes upgrade-insecure-requests, then the new top-level load
// will be upgraded to HTTPS.
bool OnNewURI(nsIURI* aURI, nsIChannel* aChannel,
nsIPrincipal* aTriggeringPrincipal,
nsIPrincipal* aPrincipalToInherit,
nsIPrincipal* aPartitionedPrincipalToInehrit,
uint32_t aLoadType, nsIContentSecurityPolicy* aCsp,
bool aFireOnLocationChange, bool aAddToGlobalHistory,
bool aCloneSHChildren);
// Helper method that is called when a new document (including any
// sub-documents - ie. frames) has been completely loaded.
MOZ_CAN_RUN_SCRIPT_BOUNDARY
nsresult EndPageLoad(nsIWebProgress* aProgress, nsIChannel* aChannel,
nsresult aResult);
// Builds an error page URI (e.g. about:neterror?etc) for the given aURI
// and displays it via the LoadErrorPage() overload below.
nsresult LoadErrorPage(nsIURI* aURI, const char16_t* aURL,
const char* aErrorPage, const char* aErrorType,
const char16_t* aDescription, const char* aCSSClass,
nsIChannel* aFailedChannel);
// This method directly loads aErrorURI as an error page. aFailedURI and
// aFailedChannel come from DisplayLoadError() or the LoadErrorPage() overload
// above.
nsresult LoadErrorPage(nsIURI* aErrorURI, nsIURI* aFailedURI,
nsIChannel* aFailedChannel);
bool DisplayLoadError(nsresult aError, nsIURI* aURI, const char16_t* aURL,
nsIChannel* aFailedChannel) {
bool didDisplayLoadError = false;
DisplayLoadError(aError, aURI, aURL, aFailedChannel, &didDisplayLoadError);
return didDisplayLoadError;
}
//
// Uncategorized
//
// Get the principal that we'll set on the channel if we're inheriting. If
// aConsiderCurrentDocument is true, we try to use the current document if
// at all possible. If that fails, we fall back on the parent document.
// If that fails too, we force creation of a content viewer and use the
// resulting principal. If aConsiderCurrentDocument is false, we just look
// at the parent.
// If aConsiderPartitionedPrincipal is true, we consider the partitioned
// principal instead of the node principal.
nsIPrincipal* GetInheritedPrincipal(
bool aConsiderCurrentDocument,
bool aConsiderPartitionedPrincipal = false);
/**
* Helper function that caches a URI and a transition for saving later.
*
* @param aChannel
* Channel that will have these properties saved
* @param aURI
* The URI to save for later
* @param aChannelRedirectFlags
* The nsIChannelEventSink redirect flags to save for later
*/
static void SaveLastVisit(nsIChannel* aChannel, nsIURI* aURI,
uint32_t aChannelRedirectFlags);
/**
* Helper function for adding a URI visit using IHistory.
*
* The IHistory API maintains chains of visits, tracking both HTTP referrers
* and redirects for a user session. VisitURI requires the current URI and
* the previous URI in the chain.
*
* Visits can be saved either during a redirect or when the request has
* reached its final destination. The previous URI in the visit may be
* from another redirect.
*
* @pre aURI is not null.
*
* @param aURI
* The URI that was just visited
* @param aPreviousURI
* The previous URI of this visit
* @param aChannelRedirectFlags
* For redirects, the redirect flags from nsIChannelEventSink
* (0 otherwise)
* @param aResponseStatus
* For HTTP channels, the response code (0 otherwise).
*/
void AddURIVisit(nsIURI* aURI, nsIURI* aPreviousURI,
uint32_t aChannelRedirectFlags,
uint32_t aResponseStatus = 0);
/**
* Internal helper funtion
*/
static void InternalAddURIVisit(
nsIURI* aURI, nsIURI* aPreviousURI, uint32_t aChannelRedirectFlags,
uint32_t aResponseStatus, mozilla::dom::BrowsingContext* aBrowsingContext,
nsIWidget* aWidget, uint32_t aLoadType);
static already_AddRefed<nsIURIFixupInfo> KeywordToURI(
const nsACString& aKeyword, bool aIsPrivateContext,
nsIInputStream** aPostData);
// Sets the current document's current state object to the given SHEntry's
// state object. The current state object is eventually given to the page
// in the PopState event.
nsresult SetDocCurrentStateObj(nsISHEntry* aShEntry);
// Returns true if would have called FireOnLocationChange,
// but did not because aFireOnLocationChange was false on entry.
// In this case it is the caller's responsibility to ensure
// FireOnLocationChange is called.
// In all other cases false is returned.
bool SetCurrentURI(nsIURI* aURI, nsIRequest* aRequest,
bool aFireOnLocationChange, uint32_t aLocationFlags);
// The following methods deal with saving and restoring content viewers
// in session history.
// mContentViewer points to the current content viewer associated with
// this docshell. When loading a new document, the content viewer is
// either destroyed or stored into a session history entry. To make sure
// that destruction happens in a controlled fashion, a given content viewer
// is always owned in exactly one of these ways:
// 1) The content viewer is active and owned by a docshell's
// mContentViewer.
// 2) The content viewer is still being displayed while we begin loading
// a new document. The content viewer is owned by the _new_
// content viewer's mPreviousViewer, and has a pointer to the
// nsISHEntry where it will eventually be stored. The content viewer
// has been close()d by the docshell, which detaches the document from
// the window object.
// 3) The content viewer is cached in session history. The nsISHEntry
// has the only owning reference to the content viewer. The viewer
// has released its nsISHEntry pointer to prevent circular ownership.
//
// When restoring a content viewer from session history, open() is called
// to reattach the document to the window object. The content viewer is
// then placed into mContentViewer and removed from the history entry.
// (mContentViewer is put into session history as described above, if
// applicable).
// Determines whether we can safely cache the current mContentViewer in
// session history. This checks a number of factors such as cache policy,
// pending requests, and unload handlers.
// |aLoadType| should be the load type that will replace the current
// presentation. |aNewRequest| should be the request for the document to
// be loaded in place of the current document, or null if such a request
// has not been created yet. |aNewDocument| should be the document that will
// replace the current document.
bool CanSavePresentation(uint32_t aLoadType, nsIRequest* aNewRequest,
mozilla::dom::Document* aNewDocument);
// There are 11 possible reasons to make a request fails to use BFCache
// (see BFCacheStatus in dom/base/Document.h), and we'd like to record
// the common combinations for reasons which make requests fail to use
// BFCache. These combinations are generated based on some local browsings,
// we need to adjust them when necessary.
enum BFCacheStatusCombo : uint16_t {
BFCACHE_SUCCESS,
SUCCESS_NOT_ONLY_TOPLEVEL =
mozilla::dom::BFCacheStatus::NOT_ONLY_TOPLEVEL_IN_BCG,
UNLOAD = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER,
UNLOAD_REQUEST = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
mozilla::dom::BFCacheStatus::REQUEST,
REQUEST = mozilla::dom::BFCacheStatus::REQUEST,
UNLOAD_REQUEST_PEER = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
mozilla::dom::BFCacheStatus::REQUEST |
mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION,
UNLOAD_REQUEST_PEER_MSE =
mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
mozilla::dom::BFCacheStatus::REQUEST |
mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION |
mozilla::dom::BFCacheStatus::CONTAINS_MSE_CONTENT,
UNLOAD_REQUEST_MSE = mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
mozilla::dom::BFCacheStatus::REQUEST |
mozilla::dom::BFCacheStatus::CONTAINS_MSE_CONTENT,
SUSPENDED_UNLOAD_REQUEST_PEER =
mozilla::dom::BFCacheStatus::SUSPENDED |
mozilla::dom::BFCacheStatus::UNLOAD_LISTENER |
mozilla::dom::BFCacheStatus::REQUEST |
mozilla::dom::BFCacheStatus::ACTIVE_PEER_CONNECTION,
REMOTE_SUBFRAMES = mozilla::dom::BFCacheStatus::CONTAINS_REMOTE_SUBFRAMES
};
void ReportBFCacheComboTelemetry(uint16_t aCombo);
// Captures the state of the supporting elements of the presentation
// (the "window" object, docshell tree, meta-refresh loads, and security
// state) and stores them on |mOSHE|.
nsresult CaptureState();
// Begin the toplevel restore process for |aSHEntry|.
// This simulates a channel open, and defers the real work until
// RestoreFromHistory is called from a PLEvent.
nsresult RestorePresentation(nsISHEntry* aSHEntry, bool* aRestoring);
// Call BeginRestore(nullptr, false) for each child of this shell.
nsresult BeginRestoreChildren();
// Method to get our current position and size without flushing
void DoGetPositionAndSize(int32_t* aX, int32_t* aY, int32_t* aWidth,
int32_t* aHeight);
// Call this when a URI load is handed to us (via OnLinkClick or
// InternalLoad). This makes sure that we're not inside unload, or that if
// we are it's still OK to load this URI.
bool IsOKToLoadURI(nsIURI* aURI);
// helpers for executing commands
nsresult GetControllerForCommand(const char* aCommand,
nsIController** aResult);
// Possibly create a ClientSource object to represent an initial about:blank
// window that has not been allocated yet. Normally we try not to create
// this about:blank window until something calls GetDocument(). We still need
// the ClientSource to exist for this conceptual window, though.
//
// The ClientSource is created with the given principal if specified. If
// the principal is not provided we will attempt to inherit it when we
// are sure it will match what the real about:blank window principal
// would have been. There are some corner cases where we cannot easily
// determine the correct principal and will not create the ClientSource.
// In these cases the initial about:blank will appear to not exist until
// its real document and window are created.
void MaybeCreateInitialClientSource(nsIPrincipal* aPrincipal = nullptr);
// Determine if a service worker is allowed to control a window in this
// docshell with the given URL. If there are any reasons it should not,
// this will return false. If true is returned then the window *may* be
// controlled. The caller must still consult either the parent controller
// or the ServiceWorkerManager to determine if a service worker should
// actually control the window.
bool ServiceWorkerAllowedToControlWindow(nsIPrincipal* aPrincipal,
nsIURI* aURI);
// Return the ClientInfo for the initial about:blank window, if it exists
// or we have speculatively created a ClientSource in
// MaybeCreateInitialClientSource(). This can return a ClientInfo object
// even if GetExtantDoc() returns nullptr.
mozilla::Maybe<mozilla::dom::ClientInfo> GetInitialClientInfo() const;
/**
* Initializes mTiming if it isn't yet.
* After calling this, mTiming is non-null. This method returns true if the
* initialization of the Timing can be reset (basically this is true if a new
* Timing object is created).
* In case the loading is aborted, MaybeResetInitTiming() can be called
* passing the return value of MaybeInitTiming(): if it's possible to reset
* the Timing, this method will do it.
*/
[[nodiscard]] bool MaybeInitTiming();
void MaybeResetInitTiming(bool aReset);
// Convenience method for getting our parent docshell. Can return null
already_AddRefed<nsDocShell> GetInProcessParentDocshell();
// Internal implementation of nsIDocShell::FirePageHideNotification.
// If aSkipCheckingDynEntries is true, it will not try to remove dynamic
// subframe entries. This is to avoid redundant RemoveDynEntries calls in all
// children docshells.
void FirePageHideNotificationInternal(bool aIsUnload,
bool aSkipCheckingDynEntries);
nsresult Dispatch(mozilla::TaskCategory aCategory,
already_AddRefed<nsIRunnable>&& aRunnable);
void SetupReferrerInfoFromChannel(nsIChannel* aChannel);
void SetReferrerInfo(nsIReferrerInfo* aReferrerInfo);
void ReattachEditorToWindow(nsISHEntry* aSHEntry);
void RecomputeCanExecuteScripts();
void ClearFrameHistory(nsISHEntry* aEntry);
// Determine if this type of load should update history.
static bool ShouldUpdateGlobalHistory(uint32_t aLoadType);
void UpdateGlobalHistoryTitle(nsIURI* aURI);
bool IsFrame() { return mBrowsingContext->IsFrame(); }
bool CanSetOriginAttributes();
bool ShouldBlockLoadingForBackButton();
bool ShouldDiscardLayoutState(nsIHttpChannel* aChannel);
bool HasUnloadedParent();
bool JustStartedNetworkLoad();
bool IsPrintingOrPP(bool aDisplayErrorDialog = true);
bool IsNavigationAllowed(bool aDisplayPrintErrorDialog = true,
bool aCheckIfUnloadFired = true);
nsIScrollableFrame* GetRootScrollFrame();
nsIChannel* GetCurrentDocChannel();
nsresult EnsureScriptEnvironment();
nsresult EnsureEditorData();
nsresult EnsureTransferableHookData();
nsresult EnsureFind();
nsresult EnsureCommandHandler();
nsresult RefreshURIFromQueue();
nsresult Embed(nsIContentViewer* aContentViewer,
mozilla::dom::WindowGlobalChild* aWindowActor = nullptr);
nsPresContext* GetEldestPresContext();
nsresult CheckLoadingPermissions();
nsresult LoadHistoryEntry(nsISHEntry* aEntry, uint32_t aLoadType);
nsresult LoadHistoryEntry(nsDocShellLoadState* aLoadState, uint32_t aLoadType,
bool aReloadingActiveEntry);
nsresult GetHttpChannel(nsIChannel* aChannel, nsIHttpChannel** aReturn);
nsresult ConfirmRepost(bool* aRepost);
nsresult GetPromptAndStringBundle(nsIPrompt** aPrompt,
nsIStringBundle** aStringBundle);
nsresult SetCurScrollPosEx(int32_t aCurHorizontalPos,
int32_t aCurVerticalPos);
nsPoint GetCurScrollPos();
already_AddRefed<mozilla::dom::ChildSHistory> GetRootSessionHistory();
bool CSSErrorReportingEnabled() const { return mCSSErrorReportingEnabled; }
// Handles retrieval of subframe session history for nsDocShell::LoadURI. If a
// load is requested in a subframe of the current DocShell, the subframe
// loadType may need to reflect the loadType of the parent document, or in
// some cases (like reloads), the history load may need to be cancelled. See
// function comments for in-depth logic descriptions.
void MaybeHandleSubframeHistory(nsDocShellLoadState* aLoadState);
// If we are passed a named target during InternalLoad, this method handles
// moving the load to the browsing context the target name resolves to.
nsresult PerformRetargeting(nsDocShellLoadState* aLoadState);
// Returns one of nsIContentPolicy::TYPE_DOCUMENT,