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
|
/* -*- 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/IdentityCredentialSerializationHelpers.h";
include "mozilla/dom/PermissionMessageUtils.h";
include "mozilla/dom/SessionStoreMessageUtils.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 IPCIdentityCredential;
include NeckoChannelParams;
include SessionStoreTypes;
include "mozilla/layers/LayersMessageUtils.h";
using mozilla::dom::JSActorMessageKind from "mozilla/dom/JSActor.h";
using mozilla::gfx::IntRect from "mozilla/gfx/Rect.h";
[MoveOnly] using mozilla::gfx::PaintFragment from "mozilla/gfx/CrossProcessPaint.h";
using nscolor from "nsColor.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";
[RefCounted] using class nsITransportSecurityInfo from "nsITransportSecurityInfo.h";
using mozilla::UseCounters from "mozilla/UseCounter.h";
using mozilla::dom::MaybeDiscardedWindowContext from "mozilla/dom/WindowContext.h";
[RefCounted] using mozilla::dom::FeaturePolicy from "mozilla/dom/FeaturePolicy.h";
[RefCounted] using mozilla::dom::SessionStoreRestoreData from "mozilla/dom/SessionStoreRestoreData.h";
using mozilla::dom::IdentityCredentialRequestOptions from "mozilla/dom/IdentityCredentialBinding.h";
namespace mozilla {
namespace dom {
struct JSActorMessageMeta {
nsCString actorName;
nsString messageName;
uint64_t queryId;
JSActorMessageKind kind;
};
struct IPCWebShareData
{
nsCString title;
nsCString text;
nullable 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 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);
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(nullable FeaturePolicy aContainerFeaturePolicy);
async RestoreDocShellState(DocShellRestoreState aState)
returns (bool success);
async RestoreTabContent(nullable SessionStoreRestoreData aData) returns (bool success);
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.
[LazySend] async UpdateDocumentURI(nullable 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.
[LazySend] async UpdateDocumentPrincipal(nullable nsIPrincipal aPrincipal,
nullable nsIPrincipal aStoragePrincipal);
// Update document's `documentHasLoaded` bit in this WindowGlobal.
[LazySend] async UpdateDocumentHasLoaded(bool aDocumentHasLoaded);
// Update document's 'documentHasUserInteracted' bit in this WindowGlobal.
[LazySend] async UpdateDocumentHasUserInteracted(bool aDocumentHasUserInteracted);
// Update document's sandbox flags in this WindowGlobal.
[LazySend] async UpdateSandboxFlags(uint32_t aSandboxFlags);
// Update document csp's fields in this WindowGlobal.
[LazySend] async UpdateDocumentCspSettings(bool aBlockAllMixedContent, bool aUpgradeInsecureRequests);
// Update document's cookie settings in this WindowGlobal.
[LazySend] async UpdateCookieJarSettings(CookieJarSettingsArgs cookieJarSettings);
// Update the title of the document in this WindowGlobal.
[LazySend] async UpdateDocumentTitle(nsString aTitle);
[LazySend] async UpdateDocumentSecurityInfo(nullable nsITransportSecurityInfo aSecurityInfo);
// Update the document's HTTPS-Only Mode flags in this WindowGlobal.
[LazySend] async UpdateHttpsOnlyStatus(uint32_t aHttpsOnlyStatus);
/// Send down initial document bit to the parent.
[LazySend] 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.
[LazySend] async SetClientInfo(IPCClientInfo aClientInfo);
// 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 RequestRestoreTabContent();
// Add the flags in aOnFlags to the current BFCache status and remove the
// flags in aOffFlags from the current BFCache status. See the BFCacheStatus
// enum for the valid flags.
async UpdateBFCacheStatus(uint32_t aOnFlags, uint32_t aOffFlags);
// Signal whether the first connection is added (aIsAdded = true) or
// the last connection is removed (aIsAdded = false).
async UpdateActivePeerConnectionStatus(bool aIsAdded);
/**
* Used to notify the parent when there's a change in the number of requests
* in the loadgroup. If there are no requests this will be set to Nothing().
* If there is one request this will be set to the ID of that request, if it
* implements nsIIdentChannel. If there are more than one requests this will
* be set to 0.
* Note that some requests are ignored (eg. favicon loads).
*/
async SetSingleChannelId(uint64_t? singleChannelId);
async SetDocumentDomain(nullable nsIURI aDomain);
async Destroy();
async ReloadWithHttpsOnlyException();
// Used by the Credential Manager API and FedCM to keep the discovery of
// a credential abstracted from the content process. This is required because
// credentialed requests that are specifically not partitioned are made and
// the results must not enter the child process until the user consents via
// purpose built UI.
async DiscoverIdentityCredentialFromExternalSource(IdentityCredentialRequestOptions aOptions)
returns (IPCIdentityCredential? identityCredential);
};
} // namespace dom
} // namespace mozilla
|
