netwerk/protocol/http/PHttpChannel.ipdl
author Junior Hsu <juhsu@mozilla.com>
Fri, 22 May 2020 02:21:25 +0000
changeset 531691 266fbe02da32661d5f6e1ac33fd4d41c2d21d109
parent 531560 75cccddb6e1448409a1f1ee6cdb6b9dc587b244b
child 535492 7d3bffbc7ad1a10db270809365ce3a17443c6566
permissions -rw-r--r--
Bug 1638313 - Let devtool show CORS rejected requests correctly r=necko-reviewers,mayhemer Differential Revision: https://phabricator.services.mozilla.com/D76255

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