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