The Tor Browser / file comparison

comparison: content/base/src/nsSyncLoadService.cpp

content/base/src/nsSyncLoadService.cpp

branch
TOR_BUG_9701
changeset 11
deefc01c0e14
equal deleted inserted replaced
-1:000000000000 0:753f8d5d7b44
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 /*
7 * A service that provides methods for synchronously loading a DOM in various ways.
8 */
9
10 #include "nsSyncLoadService.h"
11 #include "nsCOMPtr.h"
12 #include "nsIChannel.h"
13 #include "nsIChannelEventSink.h"
14 #include "nsIAsyncVerifyRedirectCallback.h"
15 #include "nsIInterfaceRequestor.h"
16 #include "nsString.h"
17 #include "nsWeakReference.h"
18 #include "nsIDocument.h"
19 #include "nsIDOMDocument.h"
20 #include "nsIPrincipal.h"
21 #include "nsContentUtils.h" // for kLoadAsData
22 #include "nsThreadUtils.h"
23 #include "nsNetUtil.h"
24 #include "nsAutoPtr.h"
25 #include "nsStreamUtils.h"
26 #include "nsCrossSiteListenerProxy.h"
27 #include <algorithm>
28
29 /**
30 * This class manages loading a single XML document
31 */
32
33 class nsSyncLoader : public nsIStreamListener,
34 public nsIChannelEventSink,
35 public nsIInterfaceRequestor,
36 public nsSupportsWeakReference
37 {
38 public:
39 nsSyncLoader() : mLoading(false) {}
40 virtual ~nsSyncLoader();
41
42 NS_DECL_ISUPPORTS
43
44 nsresult LoadDocument(nsIChannel* aChannel, nsIPrincipal *aLoaderPrincipal,
45 bool aChannelIsSync, bool aForceToXML,
46 nsIDOMDocument** aResult);
47
48 NS_FORWARD_NSISTREAMLISTENER(mListener->)
49 NS_DECL_NSIREQUESTOBSERVER
50
51 NS_DECL_NSICHANNELEVENTSINK
52
53 NS_DECL_NSIINTERFACEREQUESTOR
54
55 private:
56 nsresult PushAsyncStream(nsIStreamListener* aListener);
57 nsresult PushSyncStream(nsIStreamListener* aListener);
58
59 nsCOMPtr<nsIChannel> mChannel;
60 nsCOMPtr<nsIStreamListener> mListener;
61 bool mLoading;
62 nsresult mAsyncLoadStatus;
63 };
64
65 class nsForceXMLListener : public nsIStreamListener
66 {
67 public:
68 nsForceXMLListener(nsIStreamListener* aListener);
69 virtual ~nsForceXMLListener();
70
71 NS_DECL_ISUPPORTS
72 NS_FORWARD_NSISTREAMLISTENER(mListener->)
73 NS_DECL_NSIREQUESTOBSERVER
74
75 private:
76 nsCOMPtr<nsIStreamListener> mListener;
77 };
78
79 nsForceXMLListener::nsForceXMLListener(nsIStreamListener* aListener)
80 : mListener(aListener)
81 {
82 }
83
84 nsForceXMLListener::~nsForceXMLListener()
85 {
86 }
87
88 NS_IMPL_ISUPPORTS(nsForceXMLListener,
89 nsIStreamListener,
90 nsIRequestObserver)
91
92 NS_IMETHODIMP
93 nsForceXMLListener::OnStartRequest(nsIRequest *aRequest, nsISupports *aContext)
94 {
95 nsresult status;
96 aRequest->GetStatus(&status);
97 nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
98 if (channel && NS_SUCCEEDED(status)) {
99 channel->SetContentType(NS_LITERAL_CSTRING("text/xml"));
100 }
101
102 return mListener->OnStartRequest(aRequest, aContext);
103 }
104
105 NS_IMETHODIMP
106 nsForceXMLListener::OnStopRequest(nsIRequest *aRequest, nsISupports *aContext,
107 nsresult aStatusCode)
108 {
109 return mListener->OnStopRequest(aRequest, aContext, aStatusCode);
110 }
111
112 nsSyncLoader::~nsSyncLoader()
113 {
114 if (mLoading && mChannel) {
115 mChannel->Cancel(NS_BINDING_ABORTED);
116 }
117 }
118
119 NS_IMPL_ISUPPORTS(nsSyncLoader,
120 nsIStreamListener,
121 nsIRequestObserver,
122 nsIChannelEventSink,
123 nsIInterfaceRequestor,
124 nsISupportsWeakReference)
125
126 nsresult
127 nsSyncLoader::LoadDocument(nsIChannel* aChannel,
128 nsIPrincipal *aLoaderPrincipal,
129 bool aChannelIsSync,
130 bool aForceToXML,
131 nsIDOMDocument **aResult)
132 {
133 NS_ENSURE_ARG_POINTER(aResult);
134 *aResult = nullptr;
135 nsresult rv = NS_OK;
136
137 nsCOMPtr<nsIURI> loaderUri;
138 if (aLoaderPrincipal) {
139 aLoaderPrincipal->GetURI(getter_AddRefs(loaderUri));
140 }
141
142 mChannel = aChannel;
143 nsCOMPtr<nsIHttpChannel> http = do_QueryInterface(mChannel);
144 if (http) {
145 http->SetRequestHeader(NS_LITERAL_CSTRING("Accept"),
146 NS_LITERAL_CSTRING("text/xml,application/xml,application/xhtml+xml,*/*;q=0.1"),
147 false);
148 if (loaderUri) {
149 http->SetReferrer(loaderUri);
150 }
151 }
152
153 // Hook us up to listen to redirects and the like.
154 // Do this before setting up the cross-site proxy since
155 // that installs its own proxies.
156 mChannel->SetNotificationCallbacks(this);
157
158 // Get the loadgroup of the channel
159 nsCOMPtr<nsILoadGroup> loadGroup;
160 rv = aChannel->GetLoadGroup(getter_AddRefs(loadGroup));
161 NS_ENSURE_SUCCESS(rv, rv);
162
163 // Create document
164 nsCOMPtr<nsIDocument> document;
165 rv = NS_NewXMLDocument(getter_AddRefs(document));
166 NS_ENSURE_SUCCESS(rv, rv);
167
168 // Start the document load. Do this before we attach the load listener
169 // since we reset the document which drops all observers.
170 nsCOMPtr<nsIStreamListener> listener;
171 rv = document->StartDocumentLoad(kLoadAsData, mChannel,
172 loadGroup, nullptr,
173 getter_AddRefs(listener),
174 true);
175 NS_ENSURE_SUCCESS(rv, rv);
176
177 if (aForceToXML) {
178 nsCOMPtr<nsIStreamListener> forceListener =
179 new nsForceXMLListener(listener);
180 listener.swap(forceListener);
181 }
182
183 if (aLoaderPrincipal) {
184 nsRefPtr<nsCORSListenerProxy> corsListener =
185 new nsCORSListenerProxy(listener, aLoaderPrincipal, false);
186 rv = corsListener->Init(mChannel);
187 NS_ENSURE_SUCCESS(rv, rv);
188 listener = corsListener;
189 }
190
191 if (aChannelIsSync) {
192 rv = PushSyncStream(listener);
193 }
194 else {
195 rv = PushAsyncStream(listener);
196 }
197
198 http = do_QueryInterface(mChannel);
199 if (NS_SUCCEEDED(rv) && http) {
200 bool succeeded;
201 if (NS_FAILED(http->GetRequestSucceeded(&succeeded)) || !succeeded) {
202 rv = NS_ERROR_FAILURE;
203 }
204 }
205 mChannel = nullptr;
206
207 // check that the load succeeded
208 NS_ENSURE_SUCCESS(rv, rv);
209
210 NS_ENSURE_TRUE(document->GetRootElement(), NS_ERROR_FAILURE);
211
212 return CallQueryInterface(document, aResult);
213 }
214
215 nsresult
216 nsSyncLoader::PushAsyncStream(nsIStreamListener* aListener)
217 {
218 mListener = aListener;
219
220 mAsyncLoadStatus = NS_OK;
221
222 // Start reading from the channel
223 nsresult rv = mChannel->AsyncOpen(this, nullptr);
224
225 if (NS_SUCCEEDED(rv)) {
226 // process events until we're finished.
227 mLoading = true;
228 nsIThread *thread = NS_GetCurrentThread();
229 while (mLoading && NS_SUCCEEDED(rv)) {
230 bool processedEvent;
231 rv = thread->ProcessNextEvent(true, &processedEvent);
232 if (NS_SUCCEEDED(rv) && !processedEvent)
233 rv = NS_ERROR_UNEXPECTED;
234 }
235 }
236
237 mListener = nullptr;
238
239 NS_ENSURE_SUCCESS(rv, rv);
240
241 // Note that if AsyncOpen failed that's ok -- the only caller of
242 // this method nulls out mChannel immediately after we return.
243
244 return mAsyncLoadStatus;
245 }
246
247 nsresult
248 nsSyncLoader::PushSyncStream(nsIStreamListener* aListener)
249 {
250 nsCOMPtr<nsIInputStream> in;
251 nsresult rv = mChannel->Open(getter_AddRefs(in));
252 NS_ENSURE_SUCCESS(rv, rv);
253
254 mLoading = true;
255 rv = nsSyncLoadService::PushSyncStreamToListener(in, aListener, mChannel);
256 mLoading = false;
257
258 return rv;
259 }
260
261 NS_IMETHODIMP
262 nsSyncLoader::OnStartRequest(nsIRequest *aRequest, nsISupports *aContext)
263 {
264 return mListener->OnStartRequest(aRequest, aContext);
265 }
266
267 NS_IMETHODIMP
268 nsSyncLoader::OnStopRequest(nsIRequest *aRequest, nsISupports *aContext,
269 nsresult aStatusCode)
270 {
271 if (NS_SUCCEEDED(mAsyncLoadStatus) && NS_FAILED(aStatusCode)) {
272 mAsyncLoadStatus = aStatusCode;
273 }
274 nsresult rv = mListener->OnStopRequest(aRequest, aContext, aStatusCode);
275 if (NS_SUCCEEDED(mAsyncLoadStatus) && NS_FAILED(rv)) {
276 mAsyncLoadStatus = rv;
277 }
278 mLoading = false;
279
280 return rv;
281 }
282
283 NS_IMETHODIMP
284 nsSyncLoader::AsyncOnChannelRedirect(nsIChannel *aOldChannel,
285 nsIChannel *aNewChannel,
286 uint32_t aFlags,
287 nsIAsyncVerifyRedirectCallback *callback)
288 {
289 NS_PRECONDITION(aNewChannel, "Redirecting to null channel?");
290
291 mChannel = aNewChannel;
292
293 callback->OnRedirectVerifyCallback(NS_OK);
294 return NS_OK;
295 }
296
297 NS_IMETHODIMP
298 nsSyncLoader::GetInterface(const nsIID & aIID,
299 void **aResult)
300 {
301 return QueryInterface(aIID, aResult);
302 }
303
304 /* static */
305 nsresult
306 nsSyncLoadService::LoadDocument(nsIURI *aURI, nsIPrincipal *aLoaderPrincipal,
307 nsILoadGroup *aLoadGroup, bool aForceToXML,
308 nsIDOMDocument** aResult)
309 {
310 nsCOMPtr<nsIChannel> channel;
311 nsresult rv = NS_NewChannel(getter_AddRefs(channel), aURI, nullptr,
312 aLoadGroup);
313 NS_ENSURE_SUCCESS(rv, rv);
314
315 if (!aForceToXML) {
316 channel->SetContentType(NS_LITERAL_CSTRING("text/xml"));
317 }
318
319 bool isChrome = false, isResource = false;
320 bool isSync = (NS_SUCCEEDED(aURI->SchemeIs("chrome", &isChrome)) &&
321 isChrome) ||
322 (NS_SUCCEEDED(aURI->SchemeIs("resource", &isResource)) &&
323 isResource);
324
325 nsRefPtr<nsSyncLoader> loader = new nsSyncLoader();
326 return loader->LoadDocument(channel, aLoaderPrincipal, isSync,
327 aForceToXML, aResult);
328
329 }
330
331 /* static */
332 nsresult
333 nsSyncLoadService::PushSyncStreamToListener(nsIInputStream* aIn,
334 nsIStreamListener* aListener,
335 nsIChannel* aChannel)
336 {
337 // Set up buffering stream
338 nsresult rv;
339 nsCOMPtr<nsIInputStream> bufferedStream;
340 if (!NS_InputStreamIsBuffered(aIn)) {
341 int64_t chunkSize;
342 rv = aChannel->GetContentLength(&chunkSize);
343 if (NS_FAILED(rv) || chunkSize < 1) {
344 chunkSize = 4096;
345 }
346 chunkSize = std::min(int64_t(UINT16_MAX), chunkSize);
347
348 rv = NS_NewBufferedInputStream(getter_AddRefs(bufferedStream), aIn,
349 chunkSize);
350 NS_ENSURE_SUCCESS(rv, rv);
351
352 aIn = bufferedStream;
353 }
354
355 // Load
356 rv = aListener->OnStartRequest(aChannel, nullptr);
357 if (NS_SUCCEEDED(rv)) {
358 uint64_t sourceOffset = 0;
359 while (1) {
360 uint64_t readCount = 0;
361 rv = aIn->Available(&readCount);
362 if (NS_FAILED(rv) || !readCount) {
363 if (rv == NS_BASE_STREAM_CLOSED) {
364 // End of file, but not an error
365 rv = NS_OK;
366 }
367 break;
368 }
369
370 if (readCount > UINT32_MAX)
371 readCount = UINT32_MAX;
372
373 rv = aListener->OnDataAvailable(aChannel, nullptr, aIn,
374 (uint32_t)std::min(sourceOffset, (uint64_t)UINT32_MAX),
375 (uint32_t)readCount);
376 if (NS_FAILED(rv)) {
377 break;
378 }
379 sourceOffset += readCount;
380 }
381 }
382 if (NS_FAILED(rv)) {
383 aChannel->Cancel(rv);
384 }
385 aListener->OnStopRequest(aChannel, nullptr, rv);
386
387 return rv;
388 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial