author Alex Gaynor <>
Fri, 15 Mar 2019 12:55:10 +0000
changeset 464394 56f062d2e373c8cfccc4a7b81c6a86b63bbdc2ee
parent 464072 1d23b016870aef983893b745c7b76fd16c486a24
child 468674 646b72163f0055daebf5170403beaa64fe81756b
permissions -rw-r--r--
Bug 1534364 - replace OptionalIPCServiceWorkerDescriptor with IPCServiceWorkerDescriptor? in IPDL: r=valentin Differential Revision:

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et tw=80 ft=c: */

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

include protocol PHttpChannel;
include protocol PFTPChannel;
include protocol PChildToParentStream;
include BlobTypes;
include ClientIPCTypes;
include URIParams;
include IPCServiceWorkerDescriptor;
include IPCStream;
include PBackgroundSharedTypes;
include DOMTypes;

using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
using RequestHeaderTuples from "mozilla/net/PHttpChannelParams.h";
using struct nsHttpAtom from "nsHttp.h";
using class mozilla::net::nsHttpResponseHead from "nsHttpResponseHead.h";
using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
using nsILoadInfo::CrossOriginOpenerPolicy from "ipc/IPCMessageUtils.h";

namespace mozilla {
namespace net {

// CookieSettings IPDL structs

struct CookiePermissionData
  PrincipalInfo principalInfo;
  uint32_t cookiePermission;

struct CookieSettingsArgs
  // Copy of the cookie behavior and permissions for the top-level document.
  uint32_t cookieBehavior;
  CookiePermissionData[] cookiePermissions;
  bool isFixed;

// Preferrer alternative data type

struct PreferredAlternativeDataTypeParams
  nsCString type;
  nsCString contentType;
  bool deliverAltData;

// LoadInfo IPDL structs

struct RedirectHistoryEntryInfo
  PrincipalInfo       principalInfo;
  URIParams?          referrerUri;
  nsCString           remoteAddress;

struct LoadInfoArgs
  PrincipalInfo?              requestingPrincipalInfo;
  PrincipalInfo               triggeringPrincipalInfo;
  PrincipalInfo?              principalToInheritInfo;
  PrincipalInfo?              sandboxedLoadingPrincipalInfo;
  PrincipalInfo?              topLevelPrincipalInfo;
  PrincipalInfo?              topLevelStorageAreaPrincipalInfo;
  URIParams?                  resultPrincipalURI;
  uint32_t                    securityFlags;
  uint32_t                    contentPolicyType;
  uint32_t                    tainting;
  bool                        upgradeInsecureRequests;
  bool                        browserUpgradeInsecureRequests;
  bool                        browserWouldUpgradeInsecureRequests;
  bool                        verifySignedContent;
  bool                        enforceSRI;
  bool                        forceAllowDataURI;
  bool                        allowInsecureRedirectToDataURI;
  bool                        skipContentPolicyCheckForWebRequest;
  bool                        forceInheritPrincipalDropped;
  uint64_t                    innerWindowID;
  uint64_t                    outerWindowID;
  uint64_t                    parentOuterWindowID;
  uint64_t                    topOuterWindowID;
  uint64_t                    frameOuterWindowID;
  uint64_t                    browsingContextID;
  uint64_t                    frameBrowsingContextID;
  bool                        initialSecurityCheckDone;
  bool                        isInThirdPartyContext;
  bool                        isDocshellReload;
  bool                        sendCSPViolationEvents;
  OriginAttributes            originAttributes;
  RedirectHistoryEntryInfo[]  redirectChainIncludingInternalRedirects;
  RedirectHistoryEntryInfo[]  redirectChain;

   * Ancestor data for use with the WebRequest API.
   * See nsILoadInfo.idl for details.
  PrincipalInfo[]             ancestorPrincipals;
  uint64_t[]                  ancestorOuterWindowIDs;

   * ClientInfo structure representing the window or worker that triggered
   * this network request.  May be Nothing if its a system internal request.
  IPCClientInfo?              clientInfo;

   * Non-subresource requests will result in the creation of a window or
   * worker client.  The reserved and initial ClientInfo values represent
   * this resulting client.  An initial ClientInfo represents an initial
   * about:blank window that will be re-used while a reserved ClientInfo
   * represents a to-be-newly-created window/worker.
  IPCClientInfo?              reservedClientInfo;
  IPCClientInfo?              initialClientInfo;

   * Subresource loads may have a controller set based on their owning
   * window/worker client.  We must send this across IPC to support
   * performing interception in the parent.
  IPCServiceWorkerDescriptor? controller;

  nsCString[]                 corsUnsafeHeaders;
  bool                        forcePreflight;
  bool                        isPreflight;
  bool                        loadTriggeredFromExternal;
  bool                        serviceWorkerTaintingSynthesized;
  bool                        documentHasUserInteracted;
  bool                        documentHasLoaded;
  nsString                    cspNonce;
  bool                        isFromProcessingFrameAttributes;
  CrossOriginOpenerPolicy     openerPolicy;

  CookieSettingsArgs cookieSettings;

 * This structure is used to carry selected properties of a LoadInfo
 * object to child processes to merge LoadInfo changes from the parent
 * process.  We don't want to use LoadInfoArgs for that since it's
 * too huge and we only care about small subpart of properties anyway.
struct ParentLoadInfoForwarderArgs
  // WebExtextensions' WebRequest API allows extensions to intercept and
  // redirect a channel to a data URI. This modifications happens in
  // the parent and needs to be mirrored to the child so that security
  // checks can pass.
  bool allowInsecureRedirectToDataURI;

  // The ServiceWorker controller that may be set in the parent when
  // interception occurs.
  IPCServiceWorkerDescriptor? controller;

  // The service worker may synthesize a Response with a particular
  // tainting value.
  uint32_t tainting;

  // We must also note that the tainting value was explicitly set
  // by the service worker.
  bool serviceWorkerTaintingSynthesized;

  bool documentHasUserInteracted;
  bool documentHasLoaded;

  CrossOriginOpenerPolicy openerPolicy;

  CookieSettingsArgs? cookieSettings;

  // IMPORTANT: when you add new properites here you must also update
  // LoadInfoToParentLoadInfoForwarder and MergeParentLoadInfoForwarder
  // in BackgroundUtils.cpp/.h!

 * This structure is used to carry selected properties of a LoadInfo
 * object to the parent process that might have changed in the child
 * during a redirect.  We don't want to use LoadInfoArgs for that since
 * it's too huge and we only care about small subpart of properties
 * anyway.
struct ChildLoadInfoForwarderArgs
  // The reserved and initial ClientInfo values may change during a
  // redirect if the new channel is cross-origin to the old channel.
  IPCClientInfo? reservedClientInfo;
  IPCClientInfo? initialClientInfo;

  // The ServiceWorker controller may be cleared in the child during
  // a redirect.
  IPCServiceWorkerDescriptor? controller;

// HTTP IPDL structs

struct CorsPreflightArgs
  nsCString[]   unsafeHeaders;

struct HttpChannelOpenArgs
  URIParams                   uri;
  // - TODO: bug 571161: unclear if any HTTP channel clients ever
  // set originalURI != uri (about:credits?); also not clear if
  // chrome channel would ever need to know.  Get rid of next arg?
  URIParams?                  original;
  URIParams?                  doc;
  URIParams?                  originalReferrer;
  uint32_t                    referrerPolicy;
  URIParams?                  apiRedirectTo;
  URIParams?                  topWindowURI;
  nsIPrincipal                topWindowPrincipal;
  uint32_t                    loadFlags;
  RequestHeaderTuples         requestHeaders;
  nsCString                   requestMethod;
  IPCStream?                  uploadStream;
  bool                        uploadStreamHasHeaders;
  int16_t                     priority;
  uint32_t                    classOfService;
  uint8_t                     redirectionLimit;
  bool                        allowSTS;
  uint32_t                    thirdPartyFlags;
  bool                        resumeAt;
  uint64_t                    startPos;
  nsCString                   entityID;
  bool                        chooseApplicationCache;
  nsCString                   appCacheClientID;
  bool                        allowSpdy;
  bool                        allowAltSvc;
  bool                        beConservative;
  uint32_t                    tlsFlags;
  LoadInfoArgs?               loadInfo;
  nsHttpResponseHead?         synthesizedResponseHead;
  nsCString                   synthesizedSecurityInfoSerialization;
  uint32_t                    cacheKey;
  uint64_t                    requestContextID;
  CorsPreflightArgs?          preflightArgs;
  uint32_t                    initialRwin;
  bool                        blockAuthPrompt;
  bool                        suspendAfterSynthesizeResponse;
  bool                        allowStaleCacheContent;
  nsCString                   contentTypeHint;
  uint32_t                    corsMode;
  uint32_t                    redirectMode;
  uint64_t                    channelId;
  nsString                    integrityMetadata;
  uint64_t                    contentWindowId;
  PreferredAlternativeDataTypeParams[] preferredAlternativeTypes;
  uint64_t                    topLevelOuterContentWindowId;
  TimeStamp                   launchServiceWorkerStart;
  TimeStamp                   launchServiceWorkerEnd;
  TimeStamp                   dispatchFetchEventStart;
  TimeStamp                   dispatchFetchEventEnd;
  TimeStamp                   handleFetchEventStart;
  TimeStamp                   handleFetchEventEnd;
  bool                        forceMainDocumentChannel;
  TimeStamp                   navigationStartTimeStamp;

struct HttpChannelConnectArgs
  uint32_t registrarId;
  bool shouldIntercept;

union HttpChannelCreationArgs
  HttpChannelOpenArgs;      // For AsyncOpen: the common case.
  HttpChannelConnectArgs;   // Used for redirected-to channels

// FTP IPDL structs

struct FTPChannelOpenArgs
  URIParams                 uri;
  uint64_t                  startPos;
  nsCString                 entityID;
  IPCStream?                uploadStream;
  LoadInfoArgs?             loadInfo;
  uint32_t                  loadFlags;

struct FTPChannelConnectArgs
  uint32_t channelId;

union FTPChannelCreationArgs
  FTPChannelOpenArgs;      // For AsyncOpen: the common case.
  FTPChannelConnectArgs;   // Used for redirected-to channels

struct HttpChannelDiverterArgs
  PHttpChannel mChannel;
  bool mApplyConversion;

union ChannelDiverterArgs

struct CookieStruct
  nsCString name;
  nsCString value;
  nsCString host;
  nsCString path;
  int64_t   expiry;
  int64_t   lastAccessed;
  int64_t   creationTime;
  bool      isHttpOnly;
  bool      isSession;
  bool      isSecure;
  int8_t    sameSite;

} // namespace ipc
} // namespace mozilla