summaryrefslogtreecommitdiffstats
path: root/netwerk/protocol/http/PHttpTransaction.ipdl
blob: bb39f7dd19a7dd79534e30df161f4f78ab861bff (plain)
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
/* -*- 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 PSocketProcess;
include protocol PInputChannelThrottleQueue;

include IPCStream;
include NeckoChannelParams;

include "mozilla/ipc/TransportSecurityInfoUtils.h";
include "mozilla/net/NeckoMessageUtils.h";
include "mozilla/net/ClassOfService.h";

using class mozilla::net::nsHttpRequestHead from "nsHttpRequestHead.h";
using class mozilla::net::nsHttpHeaderArray from "nsHttpHeaderArray.h";
using mozilla::net::NetAddr from "mozilla/net/DNS.h";
using mozilla::net::ClassOfService from "mozilla/net/ClassOfService.h";
[RefCounted] using class nsITransportSecurityInfo from "nsITransportSecurityInfo.h";
using mozilla::net::TRRSkippedReason from "nsITRRSkipReason.h";
using nsIRequest::TRRMode from "nsIRequest.h";

namespace mozilla {
namespace net {

struct H2PushedStreamArg {
  PHttpTransaction transWithPushedStream;
  uint32_t pushedStreamId;
};

struct NetworkAddressArg {
  NetAddr selfAddr;
  NetAddr peerAddr;
  bool resolvedByTRR;
  TRRMode mode;
  TRRSkippedReason trrSkipReason;
  bool echConfigUsed;
};

protocol PHttpTransaction
{
  manager PSocketProcess;

parent:
  async OnStartRequest(nsresult                            status,
                       nsHttpResponseHead?                 responseHead,
                       nullable nsITransportSecurityInfo   securityInfo,
                       bool                                proxyConnectFailed,
                       TimingStructArgs                    timings,
                       int32_t                             proxyConnectResponseCode,
                       uint8_t[]                           dataForSniffer,
                       nsCString?                          altSvcUsed,
                       bool                                dataToChildProcess,
                       bool                                restarted,
                       uint32_t                            HTTPSSVCReceivedStage,
                       bool                                supportsHttp3,
                       TRRMode trrMode,
                       TRRSkippedReason trrSkipReason);
  async OnTransportStatus(nsresult status,
                          int64_t progress,
                          int64_t progressMax,
                          NetworkAddressArg? networkAddressArg);
  async OnDataAvailable(nsCString data,
                        uint64_t  offset,
                        uint32_t  count);
  async OnStopRequest(nsresult status,
                      bool responseIsComplete,
                      int64_t transferSize,
                      TimingStructArgs timings,
                      nsHttpHeaderArray? responseTrailers,
                      TransactionObserverResult? transactionObserverResult,
                      TimeStamp lastActiveTabOptimization,
                      uint32_t caps,
                      HttpConnectionInfoCloneArgs connInfoArgs);
  async OnInitFailed(nsresult status);
  async OnH2PushStream(uint32_t pushedStreamId,
                       nsCString resourceUrl,
                       nsCString requestString);
  async EarlyHint(nsCString linkHeader, nsCString referrerPolicy, nsCString cspHeader);

child:
  async __delete__();
  async Init(uint32_t caps,
             HttpConnectionInfoCloneArgs aArgs,
             nsHttpRequestHead reqHeaders,
             IPCStream? requestBody,
             uint64_t reqContentLength,
             bool reqBodyIncludesHeaders,
             uint64_t topLevelOuterContentWindowId,
             uint8_t httpTrafficCategory,
             uint64_t requestContextID,
             ClassOfService classOfService,
             uint32_t initialRwin,
             bool responseTimeoutEnabled,
             uint64_t channelId,
             bool hasTransactionObserver,
             H2PushedStreamArg? pushedStreamArg,
             PInputChannelThrottleQueue? throttleQueue,
             bool aIsDocumentLoad,
             TimeStamp aRedirectStart,
             TimeStamp aRedirectEnd);

  async CancelPump(nsresult status);
  async SuspendPump();
  async ResumePump();

  async SetDNSWasRefreshed();
  async DontReuseConnection();
  async SetH2WSConnRefTaken();
};

} // namespace net
} // namespace mozilla