DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (995b67ef37a9)

VCS Links

Line Code
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
/* -*- 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 "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";
using refcounted class nsIReferrerInfo from "mozilla/dom/ReferrerInfoUtils.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 SetClassOfService(uint32_t cos);

  async SetCacheTokenCachedCharset(nsCString charset);

  async Suspend();
  async Resume();

  async Cancel(nsresult status);

  // Reports approval/veto of redirect by child process redirect observers
  async Redirect2Verify(nsresult result, RequestHeaderTuples changedHeaders,
                        ChildLoadInfoForwarderArgs loadInfoForwarder,
                        uint32_t loadFlags, nsIReferrerInfo referrerInfo,
                        URIParams? apiRedirectTo,
                        CorsPreflightArgs? corsPreflightArgs,
                        bool chooseAppcache);

  // Sent to the parent in order signal that the child side listeners have been
  // set up and the parent side of the channel can be opened.
  async CrossProcessRedirectDone(nsresult result);

  // 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(nsresult            channelStatus,
                       nsHttpResponseHead  responseHead,
                       bool                useResponseHead,
                       nsHttpHeaderArray   requestHeaders,
                       ParentLoadInfoForwarderArgs loadInfoForwarder,
                       bool                isFromCache,
                       bool                isRacing,
                       bool                cacheEntryAvailable,
                       uint64_t            cacheEntryId,
                       int32_t             cacheFetchCount,
                       uint32_t            cacheExpirationTime,
                       nsCString           cachedCharset,
                       nsCString           securityInfoSerialization,
                       NetAddr             selfAddr,
                       NetAddr             peerAddr,
                       int16_t             redirectCount,
                       uint32_t            cacheKey,
                       nsCString           altDataType,
                       int64_t             altDataLength,
                       bool                deliveringAltData,
                       bool                applyConversion,
                       bool                isResolvedByTRR,
                       ResourceTimingStruct timing);

  // 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);

  // 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);

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