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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 protocol PContent;
include protocol PHttpChannel;
include protocol PCookieService;
include protocol PBrowser;
include protocol PFTPChannel;
include protocol PWebSocket;
include protocol PWebSocketEventListener;
include protocol PTCPSocket;
include protocol PTCPServerSocket;
include protocol PUDPSocket;
include protocol PDNSRequest;
include protocol PFileDescriptorSet;
include protocol PDataChannel;
include protocol PSimpleChannel;
include protocol PTransportProvider;
include protocol PChildToParentStream; //FIXME: bug #792908
include protocol PParentToChildStream; //FIXME: bug #792908
include protocol PStunAddrsRequest;
include protocol PFileChannel;
include protocol PClassifierDummyChannel;
include protocol PWebrtcTCPSocket;
include protocol PSocketProcessBridge;
include protocol PDocumentChannel;
include IPCStream;
include NeckoChannelParams;
include protocol PAltDataOutputStream;
include "mozilla/dom/PermissionMessageUtils.h";
using mozilla::dom::MaybeDiscardedBrowsingContext from "mozilla/dom/BrowsingContext.h";
using class IPC::SerializedLoadContext from "SerializedLoadContext.h";
using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
using refcounted class nsIInputStream from "mozilla/ipc/IPCStreamUtils.h";
using refcounted class nsIURI from "mozilla/ipc/URIUtils.h";
using refcounted class nsIPrincipal from "nsIPrincipal.h";
namespace mozilla {
namespace net {
//-------------------------------------------------------------------
nested(upto inside_cpow) sync protocol PNecko
{
manager PContent;
manages PHttpChannel;
manages PCookieService;
manages PFTPChannel;
manages PWebSocket;
manages PWebSocketEventListener;
manages PTCPSocket;
manages PTCPServerSocket;
manages PUDPSocket;
manages PDNSRequest;
manages PDataChannel;
manages PSimpleChannel;
manages PFileChannel;
manages PTransportProvider;
manages PAltDataOutputStream;
manages PStunAddrsRequest;
manages PClassifierDummyChannel;
manages PWebrtcTCPSocket;
manages PDocumentChannel;
parent:
async __delete__();
nested(inside_cpow) async PCookieService();
async PHttpChannel(nullable PBrowser browser,
SerializedLoadContext loadContext,
HttpChannelCreationArgs args);
async PFTPChannel(nullable PBrowser browser, SerializedLoadContext loadContext,
FTPChannelCreationArgs args);
async PWebSocket(nullable PBrowser browser, SerializedLoadContext loadContext,
uint32_t aSerialID);
async PTCPServerSocket(uint16_t localPort, uint16_t backlog, bool useArrayBuffers);
async PUDPSocket(nsIPrincipal principal, nsCString filter);
async PDNSRequest(nsCString hostName, nsCString trrServer, uint16_t type,
OriginAttributes originAttributes, uint32_t flags);
async PDocumentChannel(MaybeDiscardedBrowsingContext browsingContext,
DocumentChannelCreationArgs args);
async PWebSocketEventListener(uint64_t aInnerWindowID);
/* Predictor Methods */
async PredPredict(nsIURI targetURI, nsIURI sourceURI,
uint32_t reason, OriginAttributes originAttributes,
bool hasVerifier);
async PredLearn(nsIURI targetURI, nsIURI sourceURI,
uint32_t reason, OriginAttributes originAttributes);
async PredReset();
async SpeculativeConnect(nsIURI uri, nsIPrincipal principal, bool anonymous);
async HTMLDNSPrefetch(nsString hostname, bool isHttps,
OriginAttributes originAttributes, uint32_t flags);
async CancelHTMLDNSPrefetch(nsString hostname, bool isHttps,
OriginAttributes originAttributes,
uint32_t flags, nsresult reason);
/**
* channelId is used to establish a connection between redirect channels in
* the parent and the child when we're redirecting to a data: URI.
*/
async PDataChannel(uint32_t channelId);
async PSimpleChannel(uint32_t channelId);
async PFileChannel(uint32_t channelId);
async PClassifierDummyChannel(nsIURI uri, nsIURI aTopWindowURI,
nsresult aTopWindowURIResult,
LoadInfoArgs? loadInfo);
/**
* These are called from the child with the results of the auth prompt.
* callbackId is the id that was passed in PBrowser::AsyncAuthPrompt,
* corresponding to an nsIAuthPromptCallback
*/
async OnAuthAvailable(uint64_t callbackId, nsString user,
nsString password, nsString domain);
async OnAuthCancelled(uint64_t callbackId, bool userCancel);
async RequestContextLoadBegin(uint64_t rcid);
async RequestContextAfterDOMContentLoaded(uint64_t rcid);
async RemoveRequestContext(uint64_t rcid);
async PAltDataOutputStream(nsCString type, int64_t predictedSize, PHttpChannel channel);
async PStunAddrsRequest();
/* tabId is only required for web-proxy support, which isn't always needed */
async PWebrtcTCPSocket(TabId? tabId);
/**
* WebExtension-specific remote resource loading
*/
async GetExtensionStream(nsIURI uri) returns (nsIInputStream stream);
async GetExtensionFD(nsIURI uri) returns (FileDescriptor fd);
async InitSocketProcessBridge()
returns (Endpoint<PSocketProcessBridgeChild> endpoint);
async EnsureHSTSData()
returns (bool result);
/**
* Page thumbnails remote resource loading
*/
async GetPageThumbStream(nsIURI uri) returns (nsIInputStream stream);
child:
/*
* Bring up the http auth prompt for a nested remote mozbrowser.
* NestedFrameId is the id corresponding to the PBrowser. It is the same id
* that was passed to the PBrowserOrId param in to the PHttpChannel constructor
*/
async AsyncAuthPromptForNestedFrame(TabId nestedFrameId, nsCString uri,
nsString realm, uint64_t callbackId);
/* Predictor Methods */
async PredOnPredictPrefetch(nsIURI uri, uint32_t httpStatus);
async PredOnPredictPreconnect(nsIURI uri);
async PredOnPredictDNS(nsIURI uri);
async SpeculativeConnectRequest();
// Using medium high priority to deliver this notification possibly sooner than we
// enter poll() on the child process with infinite timeout.
prio(mediumhigh) async NetworkChangeNotification(nsCString type);
async PTransportProvider();
both:
// Actually we need PTCPSocket() for parent. But ipdl disallows us having different
// signatures on parent and child. So when constructing the parent side object, we just
// leave host/port unused.
async PTCPSocket(nsString host, uint16_t port);
};
} // namespace net
} // namespace mozilla
|
