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 (d38398e5144e)

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
/* -*- 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 PURLClassifierInfo;

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 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, uint32_t referrerPolicy,
                        OptionalURIParams referrerUri,
                        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  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();

  // Tell the child that the resource being loaded is on the tracking
  // protection list.
  async NotifyTrackingResource();

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

  // Tell the child information of matched URL againts SafeBrowsing list
  async SetClassifierMatchedInfo(ClassifierInfo info);

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