7d714025933ad46c22847c1987e9ca9ffd3cd3c7
[jquery.git] / src / transports / xhr.js
1 (function( jQuery ) {
2
3 var // Next fake timer id
4         xhrPollingId = jQuery.now(),
5
6         // Callbacks hashtable
7         xhrs = {},
8
9         // #5280: see end of file
10         xhrUnloadAbortMarker = [];
11
12
13 jQuery.ajax.transport( function( s , determineDataType ) {
14
15         // Cross domain only allowed if supported through XMLHttpRequest
16         if ( ! s.crossDomain || jQuery.support.cors ) {
17
18                 var callback;
19
20                 return {
21
22                         send: function(headers, complete) {
23
24                                 var xhr = s.xhr(),
25                                         handle;
26
27                                 // Open the socket
28                                 // Passing null username, generates a login popup on Opera (#2865)
29                                 if ( s.username ) {
30                                         xhr.open(s.type, s.url, s.async, s.username, s.password);
31                                 } else {
32                                         xhr.open(s.type, s.url, s.async);
33                                 }
34
35                                 // Requested-With header
36                                 // Not set for crossDomain requests with no content
37                                 // (see why at http://trac.dojotoolkit.org/ticket/9486)
38                                 // Won't change header if already provided in beforeSend
39                                 if ( ! ( s.crossDomain && ! s.hasContent ) && ! headers["x-requested-with"] ) {
40                                         headers["x-requested-with"] = "XMLHttpRequest";
41                                 }
42
43                                 // Need an extra try/catch for cross domain requests in Firefox 3
44                                 try {
45
46                                         jQuery.each(headers, function(key,value) {
47                                                 xhr.setRequestHeader(key,value);
48                                         });
49
50                                 } catch(_) {}
51
52                                 // Do send the request
53                                 try {
54                                         xhr.send( ( s.hasContent && s.data ) || null );
55                                 } catch(e) {
56                                         complete(0, "error", "" + e);
57                                         return;
58                                 }
59
60                                 // Listener
61                                 callback = function ( abortStatusText ) {
62
63                                         // Was never called and is aborted or complete
64                                         if ( callback && ( abortStatusText || xhr.readyState === 4 ) ) {
65
66                                                 // Do not listen anymore
67                                                 if (handle) {
68                                                         xhr.onreadystatechange = jQuery.noop;
69                                                         delete xhrs[ handle ];
70                                                         handle = undefined;
71                                                 }
72
73                                                 callback = 0;
74
75                                                 // Get info
76                                                 var status, statusText, response, responseHeaders;
77
78                                                 if ( abortStatusText ) {
79
80                                                         if ( xhr.readyState !== 4 ) {
81                                                                 xhr.abort();
82                                                         }
83
84                                                         // Stop here if unloadAbort
85                                                         if ( abortStatusText === xhrUnloadAbortMarker ) {
86                                                                 return;
87                                                         }
88
89                                                         status = 0;
90                                                         statusText = abortStatusText;
91
92                                                 } else {
93
94                                                         status = xhr.status;
95
96                                                         try { // Firefox throws an exception when accessing statusText for faulty cross-domain requests
97
98                                                                 statusText = xhr.statusText;
99
100                                                         } catch( e ) {
101
102                                                                 statusText = ""; // We normalize with Webkit giving an empty statusText
103
104                                                         }
105
106                                                         responseHeaders = xhr.getAllResponseHeaders();
107
108                                                         // Filter status for non standard behaviours
109                                                         // (so many they seem to be the actual "standard")
110                                                         status =
111                                                                 // Opera returns 0 when it should be 304
112                                                                 // Webkit returns 0 for failing cross-domain no matter the real status
113                                                                 status === 0 ?
114                                                                         (
115                                                                                 ! s.crossDomain || statusText ? // Webkit, Firefox: filter out faulty cross-domain requests
116                                                                                 (
117                                                                                         responseHeaders ? // Opera: filter out real aborts #6060
118                                                                                         304
119                                                                                         :
120                                                                                         0
121                                                                                 )
122                                                                                 :
123                                                                                 302 // We assume 302 but could be anything cross-domain related
124                                                                         )
125                                                                         :
126                                                                         (
127                                                                                 status == 1223 ?        // IE sometimes returns 1223 when it should be 204 (see #1450)
128                                                                                         204
129                                                                                         :
130                                                                                         status
131                                                                         );
132
133                                                         // Guess response if needed & update datatype accordingly
134                                                         if ( status >= 200 && status < 300 ) {
135                                                                 response =
136                                                                         determineDataType(
137                                                                                 s,
138                                                                                 xhr.getResponseHeader("content-type"),
139                                                                                 xhr.responseText,
140                                                                                 xhr.responseXML );
141                                                         }
142                                                 }
143
144                                                 // Call complete
145                                                 complete(status,statusText,response,responseHeaders);
146                                         }
147                                 };
148
149                                 // if we're in sync mode
150                                 // or it's in cache and has been retrieved directly (IE6 & IE7)
151                                 // we need to manually fire the callback
152                                 if ( ! s.async || xhr.readyState === 4 ) {
153
154                                         callback();
155
156                                 } else {
157
158                                         // Listener is externalized to handle abort on unload
159                                         handle = xhrPollingId++;
160                                         xhrs[ handle ] = xhr;
161                                         xhr.onreadystatechange = function() {
162                                                 callback();
163                                         };
164                                 }
165                         },
166
167                         abort: function(statusText) {
168                                 if ( callback ) {
169                                         callback(statusText);
170                                 }
171                         }
172                 };
173         }
174 });
175
176 // #5280: we need to abort on unload or IE will keep connections alive
177 jQuery(window).bind( "unload" , function() {
178
179         // Abort all pending requests
180         jQuery.each(xhrs, function(_, xhr) {
181                 if ( xhr.onreadystatechange ) {
182                         xhr.onreadystatechange( xhrUnloadAbortMarker );
183                 }
184         });
185
186         // Resest polling structure to be safe
187         xhrs = {};
188
189 });
190
191 })( jQuery );