diff options
Diffstat (limited to 'netwerk/protocol/http/PHttpChannel.ipdl')
| -rw-r--r-- | netwerk/protocol/http/PHttpChannel.ipdl | 178 |
1 files changed, 178 insertions, 0 deletions
diff --git a/netwerk/protocol/http/PHttpChannel.ipdl b/netwerk/protocol/http/PHttpChannel.ipdl new file mode 100644 index 000000000..1eb25a403 --- /dev/null +++ b/netwerk/protocol/http/PHttpChannel.ipdl @@ -0,0 +1,178 @@ +/* -*- 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 InputStreamParams; +include URIParams; +include PBackgroundSharedTypes; +include NeckoChannelParams; + +include protocol PBlob; //FIXME: bug #792908 + +include "mozilla/net/NeckoMessageUtils.h"; + +using class nsHttpHeaderArray from "nsHttpHeaderArray.h"; +using mozilla::net::NetAddr from "mozilla/net/DNS.h"; +using struct mozilla::net::ResourceTimingStruct from "mozilla/net/TimingStruct.h"; + +namespace mozilla { +namespace net { + +//------------------------------------------------------------------- +protocol PHttpChannel +{ + manager PNecko; + +parent: + // Note: channels are opened during construction, so no open method here: + // see PNecko.ipdl + + async SetPriority(uint16_t priority); + async SetClassOfService(uint32_t cos); + + async SetCacheTokenCachedCharset(nsCString charset); + + async UpdateAssociatedContentSecurity(int32_t broken, + int32_t no); + async Suspend(); + async Resume(); + + async Cancel(nsresult status); + + // Reports approval/veto of redirect by child process redirect observers + async Redirect2Verify(nsresult result, RequestHeaderTuples changedHeaders, + uint32_t loadFlags, OptionalURIParams apiRedirectTo, + OptionalCorsPreflightArgs corsPreflightArgs, + bool forceHSTSPriming, bool mixedContentWouldBlock, + 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(); + + // 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(); + + async __delete__(); + +child: + async OnStartRequest(nsresult channelStatus, + nsHttpResponseHead responseHead, + bool useResponseHead, + nsHttpHeaderArray requestHeaders, + bool isFromCache, + bool cacheEntryAvailable, + uint32_t cacheExpirationTime, + nsCString cachedCharset, + nsCString securityInfoSerialization, + NetAddr selfAddr, + NetAddr peerAddr, + int16_t redirectCount, + uint32_t cacheKey, + nsCString altDataType); + + // Combines a single OnDataAvailable and its associated OnProgress & + // OnStatus calls into one IPDL message + async OnTransportAndData(nsresult channelStatus, + nsresult transportStatus, + uint64_t progress, + uint64_t progressMax, + uint64_t offset, + uint32_t count, + nsCString data); + + async OnStopRequest(nsresult channelStatus, ResourceTimingStruct timing); + + async OnProgress(int64_t progress, int64_t progressMax); + + async OnStatus(nsresult status); + + // 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 newUri, + uint32_t redirectFlags, + nsHttpResponseHead responseHead, + nsCString securityInfoSerialization, + nsCString channelId); + + // 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); + + // Tell the child that tracking protection was disabled for this load. + async NotifyTrackingProtectionDisabled(); + + // Parent has been suspended for diversion; no more events to be enqueued. + async FlushedForDiversion(); + + // Child should resume processing the ChannelEventQueue, i.e. diverting any + // OnDataAvailable and OnStopRequest messages in the queue back to the parent. + async DivertMessages(); + + // Report a security message to the console associated with this + // channel. + async ReportSecurityMessage(nsString messageTag, nsString messageCategory); + + // 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); + +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(); +}; + + +} // namespace net +} // namespace mozilla |