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
|
/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
/* 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/. */
include "mozilla/dom/DocShellMessageUtils.h";
include "mozilla/dom/FeaturePolicyUtils.h";
include "mozilla/dom/PermissionMessageUtils.h";
include "mozilla/ipc/TransportSecurityInfoUtils.h";
include "mozilla/ipc/URIUtils.h";
include protocol PBrowser;
include protocol PInProcess;
include protocol PBrowserBridge;
include DOMTypes;
include ClientIPCTypes;
include NeckoChannelParams;
include "mozilla/layers/LayersMessageUtils.h";
using JSActorMessageKind from "mozilla/dom/JSActor.h";
using mozilla::gfx::IntRect from "mozilla/gfx/Rect.h";
using moveonly mozilla::gfx::PaintFragment from "mozilla/gfx/CrossProcessPaint.h";
using nscolor from "nsColor.h";
using refcounted class nsDocShellLoadState from "nsDocShellLoadState.h";
using mozilla::dom::XPCOMPermitUnloadAction from "nsIContentViewer.h";
using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
using refcounted class nsITransportSecurityInfo from "nsITransportSecurityInfo.h";
using mozilla::UseCounters from "mozilla/UseCounter.h";
using mozilla::dom::MaybeDiscardedWindowContext from "mozilla/dom/WindowContext.h";
using refcounted mozilla::dom::FeaturePolicy from "mozilla/dom/FeaturePolicy.h";
namespace mozilla {
namespace dom {
struct JSActorMessageMeta {
nsCString actorName;
nsString messageName;
uint64_t queryId;
JSActorMessageKind kind;
};
struct IPCWebShareData
{
nsCString title;
nsCString text;
nsIURI url;
};
/**
* A PWindowGlobal actor has a lifetime matching that of a single Window Global,
* specifically a |nsGlobalWindowInner|. These actors will form a parent/child
* link either between the chrome/content process, or will be in-process, for
* documents which are loaded in the chrome process.
*/
async refcounted protocol PWindowGlobal
{
manager PBrowser or PInProcess;
child:
async __delete__();
async MakeFrameLocal(MaybeDiscardedBrowsingContext aFrameContext,
uint64_t aSwitchId);
async MakeFrameRemote(MaybeDiscardedBrowsingContext aFrameContext,
ManagedEndpoint<PBrowserBridgeChild> aEndpoint,
TabId aTabId, LayersId aLayersId) returns (bool success);
async DrawSnapshot(IntRect? aRect, float aScale, nscolor aBackgroundColor,
uint32_t aFlags) returns (PaintFragment retval);
/**
* Returns the serialized security info associated with this window.
*/
async GetSecurityInfo() returns(nsCString? serializedSecInfo);
async DispatchSecurityPolicyViolation(nsString aViolationEventJSON);
async SaveStorageAccessPermissionGranted();
async AddBlockedFrameNodeByClassifier(MaybeDiscardedBrowsingContext aNode);
/**
* Request from UI to reset the scaling zoom that is controlled by APZ.
*/
async ResetScalingZoom();
async SetContainerFeaturePolicy(FeaturePolicy aContainerFeaturePolicy);
both:
async RawMessage(JSActorMessageMeta aMetadata, ClonedMessageData? aData,
ClonedMessageData? aStack);
parent:
// Load the given URI load state into the current owner process of the given
// BrowsingContext. aTargetBC must be in the same BrowsingContextGroup as this
// window global.
async LoadURI(MaybeDiscardedBrowsingContext aTargetBC,
nsDocShellLoadState aLoadState, bool aSetNavigating);
async InternalLoad(nsDocShellLoadState aLoadState);
/// Update the URI of the document in this WindowGlobal.
async UpdateDocumentURI(nsIURI aUri);
// We expose frameAncestors to web-extensions and they extract URIs from the
// principals collected. In order to be compatible with that API, we need to
// update the document's principal. This is only allowed if the principals are
// `equals` to each other.
async UpdateDocumentPrincipal(nsIPrincipal aPrincipal);
// Update document's `documentHasLoaded` bit in this WindowGlobal.
async UpdateDocumentHasLoaded(bool aDocumentHasLoaded);
// Update document's 'documentHasUserInteracted' bit in this WindowGlobal.
async UpdateDocumentHasUserInteracted(bool aDocumentHasUserInteracted);
// Update document's sandbox flags in this WindowGlobal.
async UpdateSandboxFlags(uint32_t aSandboxFlags);
// Update document csp's fields in this WindowGlobal.
async UpdateDocumentCspSettings(bool aBlockAllMixedContent, bool aUpgradeInsecureRequests);
// Update document's cookie settings in this WindowGlobal.
async UpdateCookieJarSettings(CookieJarSettingsArgs cookieJarSettings);
// Update the title of the document in this WindowGlobal.
async UpdateDocumentTitle(nsString aTitle);
async UpdateDocumentSecurityInfo(nsITransportSecurityInfo aSecurityInfo);
// Update the document's HTTPS-Only Mode flags in this WindowGlobal.
async UpdateHttpsOnlyStatus(uint32_t aHttpsOnlyStatus);
/// Send down initial document bit to the parent.
async SetIsInitialDocument(bool aIsInitialDocument);
// Attempts to perform a "Web Share".
async Share(IPCWebShareData aData) returns (nsresult rv);
// Get content blocking events from the parent process.
async GetContentBlockingEvents() returns (uint32_t events);
// Send the ClientInfo associated with a top-level document load.
async SetClientInfo(IPCClientInfo aClientInfo);
/**
* Inform the parent that the document will preload a resource if the
* network.preload pref is enabled.
*/
async UpdateDocumentWouldPreloadResources();
/**
* Submit load event telemetry affiliated with whether or not the document
* tree preloaded any resources.
*/
async SubmitLoadEventPreloadTelemetry(TimeStamp aNavigationStart,
TimeStamp aLoadStart,
TimeStamp aLoadEnd);
/**
* Submit Time-to-First-Interaction telemetry correlated with whether or not
* the document tree preloaded any resources.
*/
async SubmitTimeToFirstInteractionPreloadTelemetry(uint32_t aMillis);
/**
* Submit Load Input Event Response time telemetry correlated with whether
* or not the document tree preloaded any resources.
*/
async SubmitLoadInputEventResponsePreloadTelemetry(uint32_t aMillis);
// Checks whether any "beforeunload" event listener in the document subtree
// wants to block unload, and prompts the user to allow if any does (depending
// on the action specified, using nsIContentViewer::PermitUnloadAction
// values). The sender is responsible for checking documents in its own
// process, and passing true for `aHasInProcessBlocker` if any exist. Windows
// hosted outside of the caller process will be checked automatically.
async CheckPermitUnload(bool aHasInProcessBlocker, XPCOMPermitUnloadAction aAction)
returns (bool permitUnload);
/**
* Informs the parent process that the document in aTop should expect to
* receive page use counter contributions from the document in this
* WindowGlobal.
*/
async ExpectPageUseCounters(MaybeDiscardedWindowContext aTop);
/**
* Accumulates use counter data from the document in this WindowGlobal into
* the document previously passed into the ExpectPageUseCounters call.
*/
async AccumulatePageUseCounters(UseCounters aUseCounters);
async Destroy();
};
} // namespace dom
} // namespace mozilla
|
