Source code

Revision control

Other Tools

/* -*- 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 PNecko;
include protocol PStreamFilter;
include InputStreamParams;
include URIParams;
include PBackgroundSharedTypes;
include NeckoChannelParams;
include IPCServiceWorkerDescriptor;
include IPCStream;
include HttpChannelParams;
include PURLClassifierInfo;
include "mozilla/net/NeckoMessageUtils.h";
using refcounted class nsIReferrerInfo from "mozilla/dom/ReferrerInfoUtils.h";
using nsIHttpChannel::FlashPluginState from "mozilla/net/NeckoMessageUtils.h";
namespace mozilla {
namespace net {
//-------------------------------------------------------------------
refcounted protocol PHttpChannel
{
manager PNecko;
parent:
// Note: channels are opened during construction, so no open method here:
// see PNecko.ipdl
async SetClassOfService(uint32_t cos);
async SetCacheTokenCachedCharset(nsCString charset);
async Suspend();
async Resume();
async Cancel(nsresult status, uint32_t requestBlockingReason);
// Reports approval/veto of redirect by child process redirect observers
async Redirect2Verify(nsresult result, RequestHeaderTuples changedHeaders,
uint32_t sourceRequestBlockingReason,
ChildLoadInfoForwarderArgs? targetLoadInfoForwarder,
uint32_t loadFlags, nsIReferrerInfo referrerInfo,
URIParams? apiRedirectTo,
CorsPreflightArgs? corsPreflightArgs,
bool chooseAppcache);
// For document loads we keep this protocol open after child's
// OnStopRequest, and send this msg (instead of __delete__) to allow
// partial cleanup on parent.
async DocumentChannelCleanup(bool clearCacheEntry);
// This might have to be sync. If this fails we must fail the document load
// to avoid endless loop.
//
// Explanation: the document loaded was loaded from the offline cache. But
// the cache group id (the manifest URL) of the cache group it was loaded
// from is different then the manifest the document refers to in the html
// tag. If we detect this during the cache selection algorithm, we must not
// load this document from the offline cache group it was just loaded from.
// Marking the cache entry as foreign in its cache group will prevent
// the document to load from the bad offline cache group. After it is marked,
// we reload the document to take the effect. If we fail to mark the entry
// as foreign, we will end up in the same situation and reload again and
// again, indefinitely.
async MarkOfflineCacheEntryAsForeign();
// Divert OnDataAvailable to the parent.
async DivertOnDataAvailable(nsCString data,
uint64_t offset,
uint32_t count);
// Divert OnStopRequest to the parent.
async DivertOnStopRequest(nsresult statusCode);
// Child has no more events/messages to divert to the parent.
async DivertComplete();
// Child has detected a CORS check failure, so needs to tell the parent
// to remove any matching entry from the CORS preflight cache.
async RemoveCorsPreflightCacheEntry(URIParams uri,
PrincipalInfo requestingPrincipal);
// After receiving this message, the parent calls SendDeleteSelf, and makes
// sure not to send any more messages after that.
async DeletingChannel();
// Called to get the input stream when altData was delivered.
async OpenOriginalCacheInputStream();
// Called to get the input stream when altData is available.
async OpenAltDataCacheInputStream(nsCString aType);
// Tell the parent the amount bytes read by child for the e10s back pressure
// flow control
async BytesRead(int32_t count);
async __delete__();
child:
async OnStartRequest(nsHttpResponseHead responseHead,
bool useResponseHead,
nsHttpHeaderArray requestHeaders,
HttpChannelOnStartRequestArgs args);
// Combines a single OnDataAvailable and its associated OnProgress &
// OnStatus calls into one IPDL message
// This is a duplicate of the message on PHttpBackgroundChannel, and gets
// used for multi-pary streams to make synchronization when we get OnStartRequest
// multiple times easier.
async OnTransportAndData(nsresult channelStatus,
nsresult transportStatus,
uint64_t offset,
uint32_t count,
nsCString data);
// This is a duplicate of the message on PHttpBackgroundChannel, and gets
// used for multi-pary streams to make synchronization when we get OnStartRequest
// multiple times easier.
async OnStopRequest(nsresult channelStatus,
ResourceTimingStructArgs timing,
TimeStamp lastActiveTabOptimization,
nsHttpHeaderArray responseTrailers,
ConsoleReportCollected[] consoleReport);
// Used to cancel child channel if we hit errors during creating and
// AsyncOpen of nsHttpChannel on the parent.
async FailedAsyncOpen(nsresult status);
// Called to initiate content channel redirect, starts talking to sinks
// on the content process and reports result via Redirect2Verify above
async Redirect1Begin(uint32_t registrarId,
URIParams newOriginalUri,
uint32_t newLoadFlags,
uint32_t redirectFlags,
ParentLoadInfoForwarderArgs loadInfoForwarder,
nsHttpResponseHead responseHead,
nsCString securityInfoSerialization,
uint64_t channelId,
NetAddr oldPeerAddr,
ResourceTimingStructArgs timing);
// Called if redirect successful so that child can complete setup.
async Redirect3Complete();
// Associate the child with an application ids
async AssociateApplicationCache(nsCString groupID,
nsCString clientID);
// Report a security message to the console associated with this
// channel.
async ReportSecurityMessage(nsString messageTag, nsString messageCategory);
// This message is sent to a child that has been redirected to another process.
// As a consequence, it should cleanup the channel listeners and remove the
// request from the loadGroup.
async CancelRedirected();
// Tell child to delete channel (all IPDL deletes must be done from child to
// avoid races: see bug 591708).
async DeleteSelf();
// Tell the child to issue a deprecation warning.
async IssueDeprecationWarning(uint32_t warning, bool asError);
// When CORS blocks the request in the parent process, it doesn't have the
// correct window ID, so send the message to the child for logging to the web
// console.
async LogBlockedCORSRequest(nsString message, nsCString category);
async LogMimeTypeMismatch(nsCString messageName,
bool warning,
nsString url,
nsString contentType);
async AttachStreamFilter(Endpoint<PStreamFilterParent> aEndpoint);
// See ADivertableParentChannel::CancelDiversion
async CancelDiversion();
async OriginalCacheInputStreamAvailable(IPCStream? stream);
async AltDataCacheInputStreamAvailable(IPCStream? stream);
async OverrideReferrerInfoDuringBeginConnect(nsIReferrerInfo referrerInfo);
async OnProgress(int64_t progress, int64_t progressMax);
async OnStatus(nsresult status);
// Tell the child that the resource being loaded has been classified.
async NotifyClassificationFlags(uint32_t aClassificationFlags, bool aIsThirdParty);
// Tell the child that the current channel's document is not allowed to load
// flash content.
async NotifyFlashPluginStateChanged(FlashPluginState aState);
// Tell the child information of matched URL againts SafeBrowsing list
async SetClassifierMatchedInfo(ClassifierInfo info);
// Tell the child information of matched URL againts SafeBrowsing tracking list
async SetClassifierMatchedTrackingInfo(ClassifierInfo info);
// Forwards nsIMultiPartChannelListener::onAfterLastPart. Make sure we've
// disconnected our listeners, since we might not have on the last OnStopRequest.
async OnAfterLastPart(nsresult aStatus);
both:
// After receiving this message, the parent also calls
// SendFinishInterceptedRedirect, and makes sure not to send any more messages
// after that. When receiving this message, the child will call
// Send__delete__() and complete the steps required to finish the redirect.
async FinishInterceptedRedirect();
async SetPriority(int16_t priority);
};
} // namespace net
} // namespace mozilla