gecko-dev/netwerk/ipc/PNecko.ipdl

191 строка
6.8 KiB
C++

/* -*- 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 PChannelDiverter;
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 URIParams;
include NeckoChannelParams;
include PBrowserOrId;
include protocol PAltDataOutputStream;
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 "mozilla/dom/PermissionMessageUtils.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 PChannelDiverter;
manages PTransportProvider;
manages PAltDataOutputStream;
manages PStunAddrsRequest;
manages PClassifierDummyChannel;
manages PWebrtcTCPSocket;
manages PDocumentChannel;
parent:
async __delete__();
nested(inside_cpow) async PCookieService();
async PHttpChannel(PBrowserOrId browser,
SerializedLoadContext loadContext,
HttpChannelCreationArgs args);
async PFTPChannel(PBrowserOrId browser, SerializedLoadContext loadContext,
FTPChannelCreationArgs args);
async PWebSocket(PBrowserOrId 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, OriginAttributes originAttributes,
uint32_t flags);
async PDocumentChannel(PBrowserOrId browser,
SerializedLoadContext loadContext,
DocumentChannelCreationArgs args);
async PWebSocketEventListener(uint64_t aInnerWindowID);
/* Predictor Methods */
async PredPredict(URIParams? targetURI, URIParams? sourceURI,
uint32_t reason, OriginAttributes originAttributes,
bool hasVerifier);
async PredLearn(URIParams targetURI, URIParams? sourceURI,
uint32_t reason, OriginAttributes originAttributes);
async PredReset();
async SpeculativeConnect(URIParams uri, nsIPrincipal principal, bool anonymous);
async HTMLDNSPrefetch(nsString hostname, bool isHttps,
OriginAttributes originAttributes, uint16_t flags);
async CancelHTMLDNSPrefetch(nsString hostname, bool isHttps,
OriginAttributes originAttributes,
uint16_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 PChannelDiverter(ChannelDiverterArgs channel);
async PClassifierDummyChannel(nsIURI uri, nsIURI aTopWindowURI,
nsIPrincipal contentBlockingAllowListPrincipal,
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(URIParams uri) returns (nsIInputStream stream);
async GetExtensionFD(URIParams uri) returns (FileDescriptor fd);
async InitSocketProcessBridge()
returns (Endpoint<PSocketProcessBridgeChild> endpoint);
async EnsureHSTSData()
returns (bool result);
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(URIParams uri, uint32_t httpStatus);
async PredOnPredictPreconnect(URIParams uri);
async PredOnPredictDNS(URIParams uri);
async SpeculativeConnectRequest();
// Using high priority to deliver this notification possibly sooner than we
// enter poll() on the child process with infinite timeout.
prio(high) 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