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
|
/* -*- 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 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 SetPriority(uint16_t priority);
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, OptionalURIParams apiRedirectTo,
OptionalCorsPreflightArgs 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();
// 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 progress,
uint64_t progressMax,
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();
// 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);
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();
};
} // namespace net
} // namespace mozilla
|
