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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#ifndef nsURILoader_h__
#define nsURILoader_h__
#include "nsCURILoader.h"
#include "nsISupportsUtils.h"
#include "nsCOMArray.h"
#include "nsCOMPtr.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsString.h"
#include "nsIWeakReference.h"
#include "mozilla/Attributes.h"
#include "nsIStreamListener.h"
#include "nsIThreadRetargetableStreamListener.h"
#include "nsIExternalHelperAppService.h"
#include "mozilla/Logging.h"
class nsDocumentOpenInfo;
class nsURILoader final : public nsIURILoader {
public:
NS_DECL_NSIURILOADER
NS_DECL_ISUPPORTS
nsURILoader();
protected:
~nsURILoader();
/**
* Equivalent to nsIURILoader::openChannel, but allows specifying whether the
* channel is opened already.
*/
[[nodiscard]] nsresult OpenChannel(nsIChannel* channel, uint32_t aFlags,
nsIInterfaceRequestor* aWindowContext,
bool aChannelOpen,
nsIStreamListener** aListener);
/**
* we shouldn't need to have an owning ref count on registered
* content listeners because they are supposed to unregister themselves
* when they go away. This array stores weak references
*/
nsCOMArray<nsIWeakReference> m_listeners;
/**
* Logging. The module is called "URILoader"
*/
static mozilla::LazyLogModule mLog;
friend class nsDocumentOpenInfo;
};
/**
* The nsDocumentOpenInfo contains the state required when a single
* document is being opened in order to discover the content type...
* Each instance remains alive until its target URL has been loaded
* (or aborted).
*/
class nsDocumentOpenInfo : public nsIStreamListener,
public nsIThreadRetargetableStreamListener {
public:
// Real constructor
// aFlags is a combination of the flags on nsIURILoader
nsDocumentOpenInfo(nsIInterfaceRequestor* aWindowContext, uint32_t aFlags,
nsURILoader* aURILoader);
nsDocumentOpenInfo(uint32_t aFlags, bool aAllowListenerConversions);
NS_DECL_THREADSAFE_ISUPPORTS
/**
* Prepares this object for receiving data. The stream
* listener methods of this class must not be called before calling this
* method.
*/
nsresult Prepare();
// Call this (from OnStartRequest) to attempt to find an nsIStreamListener to
// take the data off our hands.
nsresult DispatchContent(nsIRequest* request, nsISupports* aCtxt);
// Call this if we need to insert a stream converter from aSrcContentType to
// aOutContentType into the StreamListener chain. DO NOT call it if the two
// types are the same, since no conversion is needed in that case.
nsresult ConvertData(nsIRequest* request, nsIURIContentListener* aListener,
const nsACString& aSrcContentType,
const nsACString& aOutContentType);
/**
* Function to attempt to use aListener to handle the load. If
* true is returned, nothing else needs to be done; if false
* is returned, then a different way of handling the load should be
* tried.
*/
bool TryContentListener(nsIURIContentListener* aListener,
nsIChannel* aChannel);
/**
* Virtual helper functions for content that we expect to be
* overriden when running in the parent process on behalf of
* a content process docshell.
* We also expect nsIStreamListener functions to be overriden
* to add functionality.
*/
/**
* Attempt to create a steam converter converting from the
* current mContentType into something else.
* Sets m_targetStreamListener if it succeeds.
*/
virtual nsresult TryStreamConversion(nsIChannel* aChannel);
/**
* Attempt to use the default content listener as our stream
* listener.
* Sets m_targetStreamListener if it succeeds.
*/
virtual bool TryDefaultContentListener(nsIChannel* aChannel);
/**
* Attempt to pass aChannel onto the external helper app service.
* Sets m_targetStreamListener if it succeeds.
*/
virtual nsresult TryExternalHelperApp(
nsIExternalHelperAppService* aHelperAppService, nsIChannel* aChannel);
/**
* Create another nsDocumentOpenInfo like this one, so that we can chain
* them together when we use a stream converter and don't know what the
* converted content type is until the converter outputs OnStartRequest.
*/
virtual nsDocumentOpenInfo* Clone() {
return new nsDocumentOpenInfo(m_originalContext, mFlags, mURILoader);
}
// nsIRequestObserver methods:
NS_DECL_NSIREQUESTOBSERVER
// nsIStreamListener methods:
NS_DECL_NSISTREAMLISTENER
// nsIThreadRetargetableStreamListener
NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
protected:
virtual ~nsDocumentOpenInfo();
protected:
/**
* The first content listener to try dispatching data to. Typically
* the listener associated with the entity that originated the load.
* This can be nullptr when running in the parent process for a content
* process docshell.
*/
nsCOMPtr<nsIURIContentListener> m_contentListener;
/**
* The stream listener to forward nsIStreamListener notifications
* to. This is set once the load is dispatched.
*/
nsCOMPtr<nsIStreamListener> m_targetStreamListener;
/**
* A pointer to the entity that originated the load. We depend on getting
* things like nsIURIContentListeners, nsIDOMWindows, etc off of it.
* This can be nullptr when running in the parent process for a content
* process docshell.
*/
nsCOMPtr<nsIInterfaceRequestor> m_originalContext;
/**
* IS_CONTENT_PREFERRED is used for the boolean to pass to CanHandleContent
* (also determines whether we use CanHandleContent or IsPreferred).
* DONT_RETARGET means that we will only try m_originalContext, no other
* listeners.
*/
uint32_t mFlags;
/**
* The type of the data we will be trying to dispatch.
*/
nsCString mContentType;
/**
* Reference to the URILoader service so we can access its list of
* nsIURIContentListeners.
* This can be nullptr when running in the parent process for a content
* process docshell.
*/
RefPtr<nsURILoader> mURILoader;
/**
* Limit of data conversion depth to prevent infinite conversion loops
*/
uint32_t mDataConversionDepthLimit;
/**
* Set to true if OnStartRequest handles the content using an
* nsIContentHandler, and the content is consumed despite
* m_targetStreamListener being nullptr.
*/
bool mUsedContentHandler = false;
/**
* True if we allow nsIURIContentListeners to return a requested
* input typeToUse, and attempt to create a matching stream converter.
* This is false when running in the parent process for a content process
* docshell
*/
bool mAllowListenerConversions = true;
};
#endif /* nsURILoader_h__ */
|
