summaryrefslogtreecommitdiffstats
path: root/ipc/glue/PBackground.ipdl
blob: b242bd13eab18b93867cb960736ff1f205ee80a0 (plain)
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
/* 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 protocol PBackgroundDataBridge;
include protocol PBackgroundIDBFactory;
include protocol PBackgroundIndexedDBUtils;
include protocol PBackgroundSDBConnection;
include protocol PBackgroundLSDatabase;
include protocol PBackgroundLSObserver;
include protocol PBackgroundLSRequest;
include protocol PBackgroundLSSimpleRequest;
include protocol PBackgroundLocalStorageCache;
include protocol PBackgroundSessionStorageManager;
include protocol PBackgroundSessionStorageService;
include protocol PBackgroundStorage;
include protocol PBackgroundTest;
include protocol PBroadcastChannel;
include protocol PCache;
include protocol PCacheStorage;
include protocol PCacheStreamControl;
include protocol PClientManager;
include protocol PEndpointForReport;
include protocol PFileSystemManager;
include protocol PFileSystemRequest;
include protocol PGamepadEventChannel;
include protocol PGamepadTestChannel;
include protocol PHttpBackgroundChannel;
include protocol PIPCClientCerts;
include protocol PIdleScheduler;
include protocol PMediaTransport;
include protocol PRemoteWorker;
include protocol PRemoteWorkerController;
include protocol PRemoteWorkerService;
include protocol PSharedWorker;
include protocol PTemporaryIPCBlob;
include protocol PFileCreator;
include protocol PMessagePort;
include protocol PCameras;
include protocol PLockManager;
include protocol PMIDIManager;
include protocol PMIDIPort;
include protocol PQuota;
include protocol PSelectTLSClientAuthCert;
include protocol PServiceWorker;
include protocol PServiceWorkerContainer;
include protocol PServiceWorkerManager;
include protocol PServiceWorkerRegistration;
include protocol PWebAuthnTransaction;
include protocol PUDPSocket;
include protocol PVerifySSLServerCert;
include protocol PVsync;
include protocol PRemoteDecoderManager;
include protocol PWebSocketConnection;
include protocol PWebTransport;
include protocol PFetch;

include ClientIPCTypes;
include DOMTypes;
include IPCBlob;
include IPCServiceWorkerDescriptor;
include IPCServiceWorkerRegistrationDescriptor;
include PBackgroundLSSharedTypes;
include PBackgroundSharedTypes;
include PBackgroundIDBSharedTypes;
include PFileSystemParams;
include ProtocolTypes;
include PSMIPCTypes;
include RemoteWorkerTypes;
include MIDITypes;

include "mozilla/dom/cache/IPCUtils.h";
include "mozilla/dom/quota/SerializationHelpers.h";
include "mozilla/dom/PermissionMessageUtils.h";
include "mozilla/layers/LayersMessageUtils.h";

using mozilla::dom::cache::Namespace
  from "mozilla/dom/cache/Types.h";

using class mozilla::dom::SSCacheCopy from "mozilla/dom/PBackgroundSessionStorageCache.h";

using mozilla::RemoteDecodeIn from "mozilla/RemoteDecoderManagerChild.h";

namespace mozilla {
namespace ipc {

[NeedsOtherPid, ChildImpl=virtual, ParentImpl=virtual]
sync protocol PBackground
{
  manages PBackgroundDataBridge;
  manages PBackgroundIDBFactory;
  manages PBackgroundIndexedDBUtils;
  manages PBackgroundSDBConnection;
  manages PBackgroundLSDatabase;
  manages PBackgroundLSObserver;
  manages PBackgroundLSRequest;
  manages PBackgroundLSSimpleRequest;
  manages PBackgroundLocalStorageCache;
  manages PBackgroundSessionStorageManager;
  manages PBackgroundSessionStorageService;
  manages PBackgroundStorage;
  manages PBackgroundTest;
  manages PBroadcastChannel;
  manages PCache;
  manages PCacheStorage;
  manages PCacheStreamControl;
  manages PClientManager;
  manages PEndpointForReport;
  manages PFileSystemRequest;
  manages PGamepadEventChannel;
  manages PGamepadTestChannel;
  manages PHttpBackgroundChannel;
  manages PIPCClientCerts;
  manages PIdleScheduler;
  manages PLockManager;
  manages PMediaTransport;
  manages PRemoteWorker;
  manages PRemoteWorkerController;
  manages PRemoteWorkerService;
  manages PSharedWorker;
  manages PTemporaryIPCBlob;
  manages PFileCreator;
  manages PMessagePort;
  manages PCameras;
  manages PQuota;
  manages PSelectTLSClientAuthCert;
  manages PServiceWorker;
  manages PServiceWorkerContainer;
  manages PServiceWorkerManager;
  manages PServiceWorkerRegistration;
  manages PWebAuthnTransaction;
  manages PWebSocketConnection;
  manages PUDPSocket;
  manages PVerifySSLServerCert;
  manages PVsync;
  manages PFetch;

parent:
  // Only called at startup during mochitests to check the basic infrastructure.
  async PBackgroundTest(nsCString testArg);

  async PBackgroundDataBridge(uint64_t channelID);

  async PBackgroundIDBFactory(LoggingInfo loggingInfo);

  async PBackgroundIndexedDBUtils();

  // Use only for testing!
  async FlushPendingFileDeletions();

  async PBackgroundSDBConnection(PersistenceType persistenceType,
                                 PrincipalInfo principalInfo);

  async PBackgroundLSDatabase(PrincipalInfo principalInfo,
                              uint32_t privateBrowsingId,
                              uint64_t datastoreId);

  async PBackgroundLSObserver(uint64_t observerId);

  /**
   * Issue an asynchronous request that will be used in a synchronous fashion
   * through complex machinations described in `PBackgroundLSRequest.ipdl` and
   * `LSObject.h`.
   */
  async PBackgroundLSRequest(LSRequestParams params);

  /**
   * Issues a simple, non-cancelable asynchronous request that's used in an
   * asynchronous fashion by callers.  (LSRequest is not simple because it used
   * in a synchronous fashion which leads to complexities regarding cancelation,
   * see `PBackgroundLSRequest.ipdl` for details.)
   */
  async PBackgroundLSSimpleRequest(LSSimpleRequestParams params);

  async PBackgroundLocalStorageCache(PrincipalInfo principalInfo,
                                     nsCString originKey,
                                     uint32_t privateBrowsingId);

  async PBackgroundSessionStorageManager(uint64_t aTopContextId);

  async PBackgroundSessionStorageService();

  async PBackgroundStorage(nsString profilePath, uint32_t privateBrowsingId);

  /**
   * Finish the setup of a new PFileSystemManager top level protocol.
   */
  async CreateFileSystemManagerParent(
      PrincipalInfo principalInfo,
      Endpoint<PFileSystemManagerParent> aParentEndpoint)
      returns(nsresult rv);

  /**
   * Finish the setup of a new PWebTransport top level protocol.
   */
  async CreateWebTransportParent(
      nsString aURL,
      nullable nsIPrincipal aPrincipal,
      IPCClientInfo?  aClientInfo,
      bool aDedicated,
      bool aRequireUnreliable,
      uint32_t aCongestionControl,
      /* Sequence<WebTransportHash>* aServerCertHashes, */
      Endpoint<PWebTransportParent> aParentEndpoint)
      returns(nsresult rv, uint8_t aReliability); // Actually WebTransportReliabityMode enum

  async PVsync();

  async PCameras();

  async PUDPSocket(PrincipalInfo? pInfo, nsCString filter);
  async PBroadcastChannel(PrincipalInfo pInfo, nsCString origin, nsString channel);

  async PServiceWorkerManager();

  async ShutdownServiceWorkerRegistrar();

  async PCacheStorage(Namespace aNamespace, PrincipalInfo aPrincipalInfo);

  async PMessagePort(nsID uuid, nsID destinationUuid, uint32_t sequenceId);

  async MessagePortForceClose(nsID uuid, nsID destinationUuid, uint32_t sequenceId);

  async PQuota();

  async ShutdownQuotaManager();

  async ShutdownBackgroundSessionStorageManagers();

  async PropagateBackgroundSessionStorageManager(uint64_t currentTopContextId, uint64_t targetTopContextId);

  async RemoveBackgroundSessionStorageManager(uint64_t topContextId);

  async GetSessionStorageManagerData(
      uint64_t aTopContextId, uint32_t aSizeLimit, bool aCancelSessionStoreTimer)
      returns(SSCacheCopy[] aCacheCopy);

  async LoadSessionStorageManagerData(uint64_t aTopContextId, SSCacheCopy[] aOriginCacheCopy);

  async PFileSystemRequest(FileSystemParams params);

  async PGamepadEventChannel();

  async PGamepadTestChannel();

  async PHttpBackgroundChannel(uint64_t channelId);

  async PWebAuthnTransaction();

  async PSharedWorker(RemoteWorkerData data,
                      uint64_t windowID,
                      MessagePortIdentifier portIdentifier);

  async PTemporaryIPCBlob();

  async PFileCreator(nsString aFullPath, nsString aType, nsString aName,
                     int64_t? lastModified, bool aExistenceCheck,
                     bool aIsFromNsIFile);

  async PClientManager();

  async CreateMIDIManager(Endpoint<PMIDIManagerParent> aEndpoint);
  async CreateMIDIPort(Endpoint<PMIDIPortParent> aEndpoint,
                       MIDIPortInfo portInfo, bool sysexEnabled);
  async HasMIDIDevice() returns (bool hasDevice);

  // This method is used to propagate storage activities from the child actor
  // to the parent actor. See StorageActivityService.
  async StorageActivity(PrincipalInfo principalInfo);

  async PServiceWorker(IPCServiceWorkerDescriptor aDescriptor);

  async PRemoteWorkerController(RemoteWorkerData aData);

  async PRemoteWorkerService();

  async PServiceWorkerContainer();

  async PServiceWorkerRegistration(IPCServiceWorkerRegistrationDescriptor aDescriptor);

  async PEndpointForReport(nsString aGroupName, PrincipalInfo aPrincipalInfo);

  async RemoveEndpoint(nsString aGroupName, nsCString aEndpointURL,
                       PrincipalInfo aPrincipalInfo);

  async PIdleScheduler();

  async PMediaTransport();

  async PSelectTLSClientAuthCert(nsCString aHostName,
                                 OriginAttributes aOriginAttributes,
                                 int32_t aPort,
                                 uint32_t aProviderFlags,
                                 uint32_t aProviderTlsFlags,
                                 ByteArray aServerCertBytes,
                                 ByteArray[] aCANames);

  async PVerifySSLServerCert(ByteArray[] aPeerCertChain,
                             nsCString aHostName,
                             int32_t aPort,
                             OriginAttributes aOriginAttributes,
                             ByteArray? aStapledOCSPResponse,
                             ByteArray? aSctsFromTLSExtension,
                             DelegatedCredentialInfoArg? aDcInfo,
                             uint32_t aProviderFlags,
                             uint32_t aCertVerifierFlags);

  async EnsureRDDProcessAndCreateBridge()
      returns (nsresult rv, Endpoint<PRemoteDecoderManagerChild> aEndpoint);

  async EnsureUtilityProcessAndCreateBridge(RemoteDecodeIn aLocation)
      returns (nsresult rv, Endpoint<PRemoteDecoderManagerChild> aEndpoint);

  async PWebSocketConnection(uint32_t aListenerId);

  async PLockManager(ContentPrincipalInfo aPrincipalInfo, nsID aClientId);

  async PIPCClientCerts();

  async PFetch();

child:
  async PCache();
  async PCacheStreamControl();

  async PRemoteWorker(RemoteWorkerData data);
};

} // namespace ipc
} // namespace mozilla