162eb4df0cfb2be21f679269a4d640d40bdb73c2
[WebKit-https.git] / WebCore / xml / XMLHttpRequest.cpp
1 /*
2  *  This file is part of the KDE libraries
3  *  Copyright (C) 2004, 2006 Apple Computer, Inc.
4  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  */
20
21 #include "config.h"
22 #include "XMLHttpRequest.h"
23
24 #include "CString.h"
25 #include "Cache.h"
26 #include "DOMImplementation.h"
27 #include "TextResourceDecoder.h"
28 #include "Event.h"
29 #include "EventListener.h"
30 #include "EventNames.h"
31 #include "ExceptionCode.h"
32 #include "FormData.h"
33 #include "Frame.h"
34 #include "FrameLoader.h"
35 #include "HTMLDocument.h"
36 #include "HTTPParsers.h"
37 #include "Page.h"
38 #include "PlatformString.h"
39 #include "RegularExpression.h"
40 #include "ResourceHandle.h"
41 #include "ResourceRequest.h"
42 #include "Settings.h"
43 #include "SubresourceLoader.h"
44 #include "TextEncoding.h"
45 #include "kjs_binding.h"
46 #include <kjs/protect.h>
47 #include <wtf/Vector.h>
48
49 namespace WebCore {
50
51 using namespace EventNames;
52
53 typedef HashSet<XMLHttpRequest*> RequestsSet;
54
55 static HashMap<Document*, RequestsSet*>& requestsByDocument()
56 {
57     static HashMap<Document*, RequestsSet*> map;
58     return map;
59 }
60
61 static void addToRequestsByDocument(Document* doc, XMLHttpRequest* req)
62 {
63     ASSERT(doc);
64     ASSERT(req);
65
66     RequestsSet* requests = requestsByDocument().get(doc);
67     if (!requests) {
68         requests = new RequestsSet;
69         requestsByDocument().set(doc, requests);
70     }
71
72     ASSERT(!requests->contains(req));
73     requests->add(req);
74 }
75
76 static void removeFromRequestsByDocument(Document* doc, XMLHttpRequest* req)
77 {
78     ASSERT(doc);
79     ASSERT(req);
80
81     RequestsSet* requests = requestsByDocument().get(doc);
82     ASSERT(requests);
83     ASSERT(requests->contains(req));
84     requests->remove(req);
85     if (requests->isEmpty()) {
86         requestsByDocument().remove(doc);
87         delete requests;
88     }
89 }
90
91 static bool canSetRequestHeader(const String& name)
92 {
93     static HashSet<String, CaseInsensitiveHash<String> > forbiddenHeaders;
94     
95     if (forbiddenHeaders.isEmpty()) {
96         forbiddenHeaders.add("accept-charset");
97         forbiddenHeaders.add("accept-encoding");
98         forbiddenHeaders.add("content-length");
99         forbiddenHeaders.add("expect");
100         forbiddenHeaders.add("date");
101         forbiddenHeaders.add("host");
102         forbiddenHeaders.add("keep-alive");
103         forbiddenHeaders.add("referer");
104         forbiddenHeaders.add("te");
105         forbiddenHeaders.add("trailer");
106         forbiddenHeaders.add("transfer-encoding");
107         forbiddenHeaders.add("upgrade");
108         forbiddenHeaders.add("via");
109     }
110     
111     return !forbiddenHeaders.contains(name);
112 }
113
114 // Determines if a string is a valid token, as defined by
115 // "token" in section 2.2 of RFC 2616.
116 static bool isValidToken(const String& name)
117 {
118     unsigned length = name.length();
119     for (unsigned i = 0; i < length; i++) {
120         UChar c = name[i];
121         
122         if (c >= 127 || c <= 32)
123             return false;
124         
125         if (c == '(' || c == ')' || c == '<' || c == '>' || c == '@' ||
126             c == ',' || c == ';' || c == ':' || c == '\\' || c == '\"' ||
127             c == '/' || c == '[' || c == ']' || c == '?' || c == '=' ||
128             c == '{' || c == '}')
129             return false;
130     }
131     
132     return true;
133 }
134     
135 static bool isValidHeaderValue(const String& name)
136 {
137     // FIXME: This should really match name against 
138     // field-value in section 4.2 of RFC 2616.
139         
140     return !name.contains('\r') && !name.contains('\n');
141 }
142     
143 XMLHttpRequestState XMLHttpRequest::getReadyState() const
144 {
145     return m_state;
146 }
147
148 const KJS::UString& XMLHttpRequest::getResponseText(ExceptionCode& ec) const
149 {
150     if (m_state < Receiving)
151         ec = INVALID_STATE_ERR;
152
153     return m_responseText;
154 }
155
156 Document* XMLHttpRequest::getResponseXML(ExceptionCode& ec) const
157 {
158     if (m_state != Loaded) {
159         ec = INVALID_STATE_ERR;
160         return 0;
161     }
162
163     if (!m_createdDocument) {
164         if (m_response.isHTTP() && !responseIsXML()) {
165             // The W3C spec requires this.
166             m_responseXML = 0;
167         } else {
168             m_responseXML = m_doc->implementation()->createDocument(0);
169             m_responseXML->open();
170             m_responseXML->setURL(m_url.url());
171             // FIXME: set Last-Modified and cookies (currently, those are only available for HTMLDocuments).
172             m_responseXML->write(String(m_responseText));
173             m_responseXML->finishParsing();
174             m_responseXML->close();
175             
176             if (!m_responseXML->wellFormed())
177                 m_responseXML = 0;
178         }
179         m_createdDocument = true;
180     }
181
182     return m_responseXML.get();
183 }
184
185 EventListener* XMLHttpRequest::onReadyStateChangeListener() const
186 {
187     return m_onReadyStateChangeListener.get();
188 }
189
190 void XMLHttpRequest::setOnReadyStateChangeListener(EventListener* eventListener)
191 {
192     m_onReadyStateChangeListener = eventListener;
193 }
194
195 EventListener* XMLHttpRequest::onLoadListener() const
196 {
197     return m_onLoadListener.get();
198 }
199
200 void XMLHttpRequest::setOnLoadListener(EventListener* eventListener)
201 {
202     m_onLoadListener = eventListener;
203 }
204
205 void XMLHttpRequest::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> eventListener, bool)
206 {
207     EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
208     if (iter == m_eventListeners.end()) {
209         ListenerVector listeners;
210         listeners.append(eventListener);
211         m_eventListeners.add(eventType.impl(), listeners);
212     } else {
213         ListenerVector& listeners = iter->second;
214         for (ListenerVector::iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
215             if (*listenerIter == eventListener)
216                 return;
217         
218         listeners.append(eventListener);
219         m_eventListeners.add(eventType.impl(), listeners);
220     }
221 }
222
223 void XMLHttpRequest::removeEventListener(const AtomicString& eventType, EventListener* eventListener, bool)
224 {
225     EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
226     if (iter == m_eventListeners.end())
227         return;
228
229     ListenerVector& listeners = iter->second;
230     for (ListenerVector::const_iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
231         if (*listenerIter == eventListener) {
232             listeners.remove(listenerIter - listeners.begin());
233             return;
234         }
235 }
236
237 bool XMLHttpRequest::dispatchEvent(PassRefPtr<Event> evt, ExceptionCode& ec, bool /*tempEvent*/)
238 {
239     // FIXME: check for other error conditions enumerated in the spec.
240     if (evt->type().isEmpty()) {
241         ec = UNSPECIFIED_EVENT_TYPE_ERR;
242         return true;
243     }
244
245     ListenerVector listenersCopy = m_eventListeners.get(evt->type().impl());
246     for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
247         evt->setTarget(this);
248         evt->setCurrentTarget(this);
249         listenerIter->get()->handleEvent(evt.get(), false);
250     }
251
252     return !evt->defaultPrevented();
253 }
254
255 XMLHttpRequest::XMLHttpRequest(Document* d)
256     : m_doc(d)
257     , m_async(true)
258     , m_loader(0)
259     , m_state(Uninitialized)
260     , m_responseText("")
261     , m_createdDocument(false)
262     , m_aborted(false)
263 {
264     ASSERT(m_doc);
265     addToRequestsByDocument(m_doc, this);
266 }
267
268 XMLHttpRequest::~XMLHttpRequest()
269 {
270     if (m_doc)
271         removeFromRequestsByDocument(m_doc, this);
272 }
273
274 void XMLHttpRequest::changeState(XMLHttpRequestState newState)
275 {
276     if (m_state != newState) {
277         m_state = newState;
278         callReadyStateChangeListener();
279     }
280 }
281
282 void XMLHttpRequest::callReadyStateChangeListener()
283 {
284     if (!m_doc || !m_doc->frame())
285         return;
286
287     RefPtr<Event> evt = new Event(readystatechangeEvent, false, false);
288     if (m_onReadyStateChangeListener) {
289         evt->setTarget(this);
290         evt->setCurrentTarget(this);
291         m_onReadyStateChangeListener->handleEvent(evt.get(), false);
292     }
293
294     ExceptionCode ec = 0;
295     dispatchEvent(evt.release(), ec, false);
296     ASSERT(!ec);
297     
298     if (m_state == Loaded) {
299         evt = new Event(loadEvent, false, false);
300         if (m_onLoadListener) {
301             evt->setTarget(this);
302             evt->setCurrentTarget(this);
303             m_onLoadListener->handleEvent(evt.get(), false);
304         }
305         
306         dispatchEvent(evt, ec, false);
307         ASSERT(!ec);
308     }
309 }
310
311 bool XMLHttpRequest::urlMatchesDocumentDomain(const KURL& url) const
312 {
313     // a local file can load anything
314     if (m_doc->isAllowedToLoadLocalResources())
315         return true;
316
317     // but a remote document can only load from the same port on the server
318     KURL documentURL = m_doc->URL();
319     if (documentURL.protocol().lower() == url.protocol().lower()
320             && documentURL.host().lower() == url.host().lower()
321             && documentURL.port() == url.port())
322         return true;
323
324     return false;
325 }
326
327 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec)
328 {
329     abort();
330     m_aborted = false;
331
332     // clear stuff from possible previous load
333     m_requestHeaders.clear();
334     m_response = ResourceResponse();
335     {
336         KJS::JSLock lock;
337         m_responseText = "";
338     }
339     m_createdDocument = false;
340     m_responseXML = 0;
341
342     ASSERT(m_state == Uninitialized);
343
344     if (!urlMatchesDocumentDomain(url)) {
345         ec = PERMISSION_DENIED;
346         return;
347     }
348
349     if (!isValidToken(method)) {
350         ec = SYNTAX_ERR;
351         return;
352     }
353     
354     m_url = url;
355
356     // Method names are case sensitive. But since Firefox uppercases method names it knows, we'll do the same.
357     String methodUpper(method.upper());
358     if (methodUpper == "CONNECT" || methodUpper == "COPY" || methodUpper == "DELETE" || methodUpper == "GET" || methodUpper == "HEAD"
359         || methodUpper == "INDEX" || methodUpper == "LOCK" || methodUpper == "M-POST" || methodUpper == "MKCOL" || methodUpper == "MOVE" 
360         || methodUpper == "OPTIONS" || methodUpper == "POST" || methodUpper == "PROPFIND" || methodUpper == "PROPPATCH" || methodUpper == "PUT" 
361         || methodUpper == "TRACE" || methodUpper == "UNLOCK")
362         m_method = methodUpper.deprecatedString();
363     else
364         m_method = method.deprecatedString();
365
366     m_async = async;
367
368     changeState(Open);
369 }
370
371 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, ExceptionCode& ec)
372 {
373     KURL urlWithCredentials(url);
374     urlWithCredentials.setUser(user.deprecatedString());
375     
376     open(method, urlWithCredentials, async, ec);
377 }
378
379 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, const String& password, ExceptionCode& ec)
380 {
381     KURL urlWithCredentials(url);
382     urlWithCredentials.setUser(user.deprecatedString());
383     urlWithCredentials.setPass(password.deprecatedString());
384     
385     open(method, urlWithCredentials, async, ec);
386 }
387
388 void XMLHttpRequest::send(const String& body, ExceptionCode& ec)
389 {
390     if (!m_doc)
391         return;
392
393     if (m_state != Open) {
394         ec = INVALID_STATE_ERR;
395         return;
396     }
397   
398     // FIXME: Should this abort or raise an exception instead if we already have a m_loader going?
399     if (m_loader)
400         return;
401
402     m_aborted = false;
403
404     ResourceRequest request(m_url);
405     request.setHTTPMethod(m_method);
406     
407     if (!body.isNull() && m_method != "GET" && m_method != "HEAD" && (m_url.protocol().lower() == "http" || m_url.protocol().lower() == "https")) {
408         String contentType = getRequestHeader("Content-Type");
409         if (contentType.isEmpty()) {
410             ExceptionCode ec = 0;
411             Settings* settings = m_doc->settings();
412             if (settings && settings->usesDashboardBackwardCompatibilityMode())
413                 setRequestHeader("Content-Type", "application/x-www-form-urlencoded", ec);
414             else
415                 setRequestHeader("Content-Type", "application/xml", ec);
416             ASSERT(ec == 0);
417         }
418
419         // FIXME: must use xmlEncoding for documents.
420         String charset = "UTF-8";
421       
422         TextEncoding m_encoding(charset);
423         if (!m_encoding.isValid()) // FIXME: report an error?
424             m_encoding = UTF8Encoding();
425
426         request.setHTTPBody(PassRefPtr<FormData>(new FormData(m_encoding.encode(body.characters(), body.length()))));
427     }
428
429     if (m_requestHeaders.size() > 0)
430         request.addHTTPHeaderFields(m_requestHeaders);
431
432     if (!m_async) {
433         Vector<char> data;
434         ResourceError error;
435         ResourceResponse response;
436
437         {
438             // avoid deadlock in case the loader wants to use JS on a background thread
439             KJS::JSLock::DropAllLocks dropLocks;
440             if (m_doc->frame()) 
441                 m_doc->frame()->loader()->loadResourceSynchronously(request, error, response, data);
442         }
443
444         m_loader = 0;
445         
446         // No exception for file:/// resources, see <rdar://problem/4962298>.
447         // Also, if we have an HTTP response, then it wasn't a network error in fact.
448         if (error.isNull() || request.url().isLocalFile() || response.httpStatusCode() > 0)
449             processSyncLoadResults(data, response);
450         else
451             ec = NETWORK_ERR;
452
453         return;
454     }
455
456     // Neither this object nor the JavaScript wrapper should be deleted while
457     // a request is in progress because we need to keep the listeners alive,
458     // and they are referenced by the JavaScript wrapper.
459     ref();
460     {
461         KJS::JSLock lock;
462         gcProtectNullTolerant(KJS::ScriptInterpreter::getDOMObject(this));
463     }
464   
465     // create can return null here, for example if we're no longer attached to a page.
466     // this is true while running onunload handlers
467     // FIXME: Maybe create can return false for other reasons too?
468     m_loader = SubresourceLoader::create(m_doc->frame(), this, request, false, true, false);
469 }
470
471 void XMLHttpRequest::abort()
472 {
473     bool hadLoader = m_loader;
474
475     m_aborted = true;
476     
477     if (hadLoader) {
478         m_loader->cancel();
479         m_loader = 0;
480     }
481
482     m_decoder = 0;
483
484     if (hadLoader)
485         dropProtection();
486
487     m_state = Uninitialized;
488 }
489
490 void XMLHttpRequest::dropProtection()        
491 {
492     {
493         KJS::JSLock lock;
494         KJS::JSValue* wrapper = KJS::ScriptInterpreter::getDOMObject(this);
495         KJS::gcUnprotectNullTolerant(wrapper);
496     
497         // the XHR object itself holds on to the responseText, and
498         // thus has extra cost even independent of any
499         // responseText or responseXML objects it has handed
500         // out. But it is protected from GC while loading, so this
501         // can't be recouped until the load is done, so only
502         // report the extra cost at that point.
503     
504         if (wrapper)
505             KJS::Collector::reportExtraMemoryCost(m_responseText.size() * 2);
506     }
507
508     deref();
509 }
510
511 void XMLHttpRequest::overrideMIMEType(const String& override)
512 {
513     m_mimeTypeOverride = override;
514 }
515     
516 void XMLHttpRequest::setRequestHeader(const String& name, const String& value, ExceptionCode& ec)
517 {
518     if (m_state != Open) {
519         Settings* settings = m_doc ? m_doc->settings() : 0;
520         if (settings && settings->usesDashboardBackwardCompatibilityMode())
521             return;
522
523         ec = INVALID_STATE_ERR;
524         return;
525     }
526
527     if (!isValidToken(name) || !isValidHeaderValue(value)) {
528         ec = SYNTAX_ERR;
529         return;
530     }
531         
532     if (!canSetRequestHeader(name)) {
533         if (m_doc && m_doc->frame() && m_doc->frame()->page())
534             m_doc->frame()->page()->chrome()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, "Refused to set unsafe header " + name, 1, String());
535         return;
536     }
537
538     if (!m_requestHeaders.contains(name)) {
539         m_requestHeaders.set(name, value);
540         return;
541     }
542     
543     String oldValue = m_requestHeaders.get(name);
544     m_requestHeaders.set(name, oldValue + ", " + value);
545 }
546
547 String XMLHttpRequest::getRequestHeader(const String& name) const
548 {
549     return m_requestHeaders.get(name);
550 }
551
552 String XMLHttpRequest::getAllResponseHeaders(ExceptionCode& ec) const
553 {
554     if (m_state < Receiving) {
555         ec = INVALID_STATE_ERR;
556         return "";
557     }
558
559     Vector<UChar> stringBuilder;
560     String separator(": ");
561
562     HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
563     for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it!= end; ++it) {
564         stringBuilder.append(it->first.characters(), it->first.length());
565         stringBuilder.append(separator.characters(), separator.length());
566         stringBuilder.append(it->second.characters(), it->second.length());
567         stringBuilder.append((UChar)'\r');
568         stringBuilder.append((UChar)'\n');
569     }
570
571     return String::adopt(stringBuilder);
572 }
573
574 String XMLHttpRequest::getResponseHeader(const String& name, ExceptionCode& ec) const
575 {
576     if (m_state < Receiving) {
577         ec = INVALID_STATE_ERR;
578         return "";
579     }
580
581     if (!isValidToken(name))
582         return "";
583
584     return m_response.httpHeaderField(name);
585 }
586
587 String XMLHttpRequest::responseMIMEType() const
588 {
589     String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
590     if (mimeType.isEmpty()) {
591         if (m_response.isHTTP())
592             mimeType = extractMIMETypeFromMediaType(m_response.httpHeaderField("Content-Type"));
593         else
594             mimeType = m_response.mimeType();
595     }
596     if (mimeType.isEmpty())
597         mimeType = "text/xml";
598     
599     return mimeType;
600 }
601
602 bool XMLHttpRequest::responseIsXML() const
603 {
604     return DOMImplementation::isXMLMIMEType(responseMIMEType());
605 }
606
607 int XMLHttpRequest::getStatus(ExceptionCode& ec) const
608 {
609     if (m_state == Uninitialized)
610         return 0;
611     
612     if (m_response.httpStatusCode() == 0) {
613         if (m_state != Receiving && m_state != Loaded)
614             // status MUST be available in these states, but we don't get any headers from non-HTTP requests
615             ec = INVALID_STATE_ERR;
616     }
617
618     return m_response.httpStatusCode();
619 }
620
621 String XMLHttpRequest::getStatusText(ExceptionCode& ec) const
622 {
623     if (m_state == Uninitialized)
624         return "";
625     
626     if (m_response.httpStatusCode() == 0) {
627         if (m_state != Receiving && m_state != Loaded)
628             // statusText MUST be available in these states, but we don't get any headers from non-HTTP requests
629             ec = INVALID_STATE_ERR;
630         return String();
631     }
632
633     // FIXME: should try to preserve status text in response
634     return "OK";
635 }
636
637 void XMLHttpRequest::processSyncLoadResults(const Vector<char>& data, const ResourceResponse& response)
638 {
639     if (!urlMatchesDocumentDomain(response.url())) {
640         abort();
641         return;
642     }
643
644     didReceiveResponse(0, response);
645     changeState(Sent);
646     if (m_aborted)
647         return;
648
649     const char* bytes = static_cast<const char*>(data.data());
650     int len = static_cast<int>(data.size());
651
652     didReceiveData(0, bytes, len);
653     if (m_aborted)
654         return;
655
656     didFinishLoading(0);
657 }
658
659 void XMLHttpRequest::didFail(SubresourceLoader* loader, const ResourceError&)
660 {
661     didFinishLoading(loader);
662 }
663
664 void XMLHttpRequest::didFinishLoading(SubresourceLoader* loader)
665 {
666     if (m_aborted)
667         return;
668         
669     ASSERT(loader == m_loader);
670
671     if (m_state < Sent)
672         changeState(Sent);
673
674     {
675         KJS::JSLock lock;
676         if (m_decoder)
677             m_responseText += m_decoder->flush();
678     }
679
680     bool hadLoader = m_loader;
681     m_loader = 0;
682
683     changeState(Loaded);
684     m_decoder = 0;
685
686     if (hadLoader)
687         dropProtection();
688 }
689
690 void XMLHttpRequest::willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse)
691 {
692     if (!urlMatchesDocumentDomain(request.url()))
693         abort();
694 }
695
696 void XMLHttpRequest::didReceiveResponse(SubresourceLoader*, const ResourceResponse& response)
697 {
698     m_response = response;
699     m_encoding = extractCharsetFromMediaType(m_mimeTypeOverride);
700     if (m_encoding.isEmpty())
701         m_encoding = response.textEncodingName();
702
703 }
704
705 void XMLHttpRequest::receivedCancellation(SubresourceLoader*, const AuthenticationChallenge& challenge)
706 {
707     m_response = challenge.failureResponse();
708 }
709
710 void XMLHttpRequest::didReceiveData(SubresourceLoader*, const char* data, int len)
711 {
712     if (m_state < Sent)
713         changeState(Sent);
714   
715     if (!m_decoder) {
716         if (!m_encoding.isEmpty())
717             m_decoder = new TextResourceDecoder("text/plain", m_encoding);
718         // allow TextResourceDecoder to look inside the m_response if it's XML or HTML
719         else if (responseIsXML())
720             m_decoder = new TextResourceDecoder("application/xml");
721         else if (responseMIMEType() == "text/html")
722             m_decoder = new TextResourceDecoder("text/html");
723         else
724             m_decoder = new TextResourceDecoder("text/plain", "UTF-8");
725     }
726     if (len == 0)
727         return;
728
729     if (len == -1)
730         len = strlen(data);
731
732     String decoded = m_decoder->decode(data, len);
733
734     {
735         KJS::JSLock lock;
736         m_responseText += decoded;
737     }
738
739     if (!m_aborted) {
740         if (m_state != Receiving)
741             changeState(Receiving);
742         else
743             // Firefox calls readyStateChanged every time it receives data, 4449442
744             callReadyStateChangeListener();
745     }
746 }
747
748 void XMLHttpRequest::cancelRequests(Document* m_doc)
749 {
750     RequestsSet* requests = requestsByDocument().get(m_doc);
751     if (!requests)
752         return;
753     RequestsSet copy = *requests;
754     RequestsSet::const_iterator end = copy.end();
755     for (RequestsSet::const_iterator it = copy.begin(); it != end; ++it)
756         (*it)->abort();
757 }
758
759 void XMLHttpRequest::detachRequests(Document* m_doc)
760 {
761     RequestsSet* requests = requestsByDocument().get(m_doc);
762     if (!requests)
763         return;
764     requestsByDocument().remove(m_doc);
765     RequestsSet::const_iterator end = requests->end();
766     for (RequestsSet::const_iterator it = requests->begin(); it != end; ++it) {
767         (*it)->m_doc = 0;
768         (*it)->abort();
769     }
770     delete requests;
771 }
772
773 } // end namespace