Renamed src/transports to src/ajax (in case we need prefilters in the future and to avoid a separate prefilters directory).

src/ajax/jsonp.js

@@ -0,0 +1,85 @@
+(function( jQuery ) {
+
+var jsc = jQuery.now(),
+	jsre = /\=\?(&|$)/,
+	rquery_jsonp = /\?/;
+
+// Default jsonp callback name
+jQuery.ajaxSettings.jsonpCallback = function() {
+	return "jsonp" + jsc++;
+};
+
+// Normalize jsonp queries
+// 1) put callback parameter in url or data
+// 2) sneakily ensure transportDataType is json
+// 3) ensure options jsonp is always provided so that jsonp requests are always
+//    json request with the jsonp option set
+jQuery.ajax.prefilter("json jsonp", function(s) {
+
+	var transportDataType = s.dataTypes[ 0 ];
+
+	s.dataTypes[ 0 ] = "json";
+
+	if ( s.jsonp ||
+		transportDataType === "jsonp" ||
+		transportDataType === "json" && ( jsre.test(s.url) || typeof(s.data) === "string" && jsre.test(s.data) ) ) {
+
+		var jsonp = s.jsonp = s.jsonp || "callback",
+			jsonpCallback = s.jsonpCallback =
+				jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
+			url = s.url.replace(jsre, "=" + jsonpCallback + "$1"),
+			data = s.url == url && typeof(s.data) === "string" ? s.data.replace(jsre, "=" + jsonpCallback + "$1") : s.data;
+
+		if ( url == s.url && data == s.data ) {
+			url = url += (rquery_jsonp.test( url ) ? "&" : "?") + jsonp + "=" + jsonpCallback;
+		}
+
+		s.url = url;
+		s.data = data;
+	}
+
+// Bind transport to json dataType
+}).transport("json", function(s) {
+
+	if ( s.jsonp ) {
+
+		// Put callback in place
+		var responseContainer,
+			jsonpCallback = s.jsonpCallback,
+			previous = window[ jsonpCallback ];
+
+		window [ jsonpCallback ] = function( response ) {
+			responseContainer = [response];
+		};
+
+		s.complete = [function() {
+
+			// Set callback back to previous value
+			window[ jsonpCallback ] = previous;
+
+			// Call if it was a function and we have a response
+			if ( previous) {
+				if ( responseContainer && jQuery.isFunction ( previous ) ) {
+					window[ jsonpCallback ] ( responseContainer[0] );
+				}
+			} else {
+				// else, more memory leak avoidance
+				try{ delete window[ jsonpCallback ]; } catch(e){}
+			}
+
+		}, s.complete ];
+
+		// Use data converter to retrieve json after script execution
+		s.converters["script json"] = function() {
+			if ( ! responseContainer ) {
+				jQuery.error( jsonpCallback + " was not called" );
+			}
+			return responseContainer[ 0 ];
+		};
+
+		// Delegate to script transport
+		return "script";
+	}
+});
+
+})( jQuery );

src/ajax/script.js

@@ -0,0 +1,82 @@
+(function( jQuery ) {
+
+// Install text to script executor
+jQuery.extend( true, jQuery.ajaxSettings , {
+
+	accepts: {
+		script: "text/javascript, application/javascript"
+	},
+
+	contents: {
+		script: /javascript/
+	},
+
+	converters: {
+		"text script": jQuery.globalEval
+	}
+} );
+
+// Bind script tag hack transport
+jQuery.ajax.transport("script", function(s) {
+
+	// Handle cache special case
+	if ( s.cache === undefined ) {
+		s.cache = false;
+	}
+
+	// This transport only deals with cross domain get requests
+	if ( s.crossDomain && s.async && ( s.type === "GET" || ! s.data ) ) {
+
+		s.global = false;
+
+		var script,
+			head = document.getElementsByTagName("head")[0] || document.documentElement;
+
+		return {
+
+			send: function(_, callback) {
+
+				script = document.createElement("script");
+
+				script.async = "async";
+
+				if ( s.scriptCharset ) {
+					script.charset = s.scriptCharset;
+				}
+
+				script.src = s.url;
+
+				// Attach handlers for all browsers
+				script.onload = script.onreadystatechange = function( _ , statusText) {
+
+					if ( ! script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
+						// Handle memory leak in IE
+						script.onload = script.onreadystatechange = null;
+
+						// Remove the script
+						if ( head && script.parentNode ) {
+							head.removeChild( script );
+						}
+
+						script = 0;
+
+						// Callback
+						callback( statusText ? 0 : 200, statusText || "success" );
+					}
+				};
+				// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
+				// This arises when a base node is used (#2709 and #4378).
+				head.insertBefore( script, head.firstChild );
+			},
+
+			abort: function(statusText) {
+				if ( script ) {
+					script.onload( 0 , statusText );
+				}
+			}
+		};
+	}
+});
+
+})( jQuery );

src/ajax/xhr.js

@@ -0,0 +1,191 @@
+(function( jQuery ) {
+
+var // Next fake timer id
+	xhrPollingId = jQuery.now(),
+
+	// Callbacks hashtable
+	xhrs = {},
+
+	// #5280: see end of file
+	xhrUnloadAbortMarker = [];
+
+
+jQuery.ajax.transport( function( s , determineDataType ) {
+
+	// Cross domain only allowed if supported through XMLHttpRequest
+	if ( ! s.crossDomain || jQuery.support.cors ) {
+
+		var callback;
+
+		return {
+
+			send: function(headers, complete) {
+
+				var xhr = s.xhr(),
+					handle;
+
+				// Open the socket
+				// Passing null username, generates a login popup on Opera (#2865)
+				if ( s.username ) {
+					xhr.open(s.type, s.url, s.async, s.username, s.password);
+				} else {
+					xhr.open(s.type, s.url, s.async);
+				}
+
+				// Requested-With header
+				// Not set for crossDomain requests with no content
+				// (see why at http://trac.dojotoolkit.org/ticket/9486)
+				// Won't change header if already provided in beforeSend
+				if ( ! ( s.crossDomain && ! s.hasContent ) && ! headers["x-requested-with"] ) {
+					headers["x-requested-with"] = "XMLHttpRequest";
+				}
+
+				// Need an extra try/catch for cross domain requests in Firefox 3
+				try {
+
+					jQuery.each(headers, function(key,value) {
+						xhr.setRequestHeader(key,value);
+					});
+
+				} catch(_) {}
+
+				// Do send the request
+				try {
+					xhr.send( ( s.hasContent && s.data ) || null );
+				} catch(e) {
+					complete(0, "error", "" + e);
+					return;
+				}
+
+				// Listener
+				callback = function ( abortStatusText ) {
+
+					// Was never called and is aborted or complete
+					if ( callback && ( abortStatusText || xhr.readyState === 4 ) ) {
+
+						// Do not listen anymore
+						if (handle) {
+							xhr.onreadystatechange = jQuery.noop;
+							delete xhrs[ handle ];
+							handle = undefined;
+						}
+
+						callback = 0;
+
+						// Get info
+						var status, statusText, response, responseHeaders;
+
+						if ( abortStatusText ) {
+
+							if ( xhr.readyState !== 4 ) {
+								xhr.abort();
+							}
+
+							// Stop here if unloadAbort
+							if ( abortStatusText === xhrUnloadAbortMarker ) {
+								return;
+							}
+
+							status = 0;
+							statusText = abortStatusText;
+
+						} else {
+
+							status = xhr.status;
+
+							try { // Firefox throws an exception when accessing statusText for faulty cross-domain requests
+
+								statusText = xhr.statusText;
+
+							} catch( e ) {
+
+								statusText = ""; // We normalize with Webkit giving an empty statusText
+
+							}
+
+							responseHeaders = xhr.getAllResponseHeaders();
+
+							// Filter status for non standard behaviours
+							// (so many they seem to be the actual "standard")
+							status =
+								// Opera returns 0 when it should be 304
+								// Webkit returns 0 for failing cross-domain no matter the real status
+								status === 0 ?
+									(
+										! s.crossDomain || statusText ? // Webkit, Firefox: filter out faulty cross-domain requests
+										(
+											responseHeaders ? // Opera: filter out real aborts #6060
+											304
+											:
+											0
+										)
+										:
+										302 // We assume 302 but could be anything cross-domain related
+									)
+									:
+									(
+										status == 1223 ?	// IE sometimes returns 1223 when it should be 204 (see #1450)
+											204
+											:
+											status
+									);
+
+							// Guess response if needed & update datatype accordingly
+							if ( status >= 200 && status < 300 ) {
+								response =
+									determineDataType(
+										s,
+										xhr.getResponseHeader("content-type"),
+										xhr.responseText,
+										xhr.responseXML );
+							}
+						}
+
+						// Call complete
+						complete(status,statusText,response,responseHeaders);
+					}
+				};
+
+				// if we're in sync mode
+				// or it's in cache and has been retrieved directly (IE6 & IE7)
+				// we need to manually fire the callback
+				if ( ! s.async || xhr.readyState === 4 ) {
+
+					callback();
+
+				} else {
+
+					// Listener is externalized to handle abort on unload
+					handle = xhrPollingId++;
+					xhrs[ handle ] = xhr;
+					xhr.onreadystatechange = function() {
+						callback();
+					};
+				}
+			},
+
+			abort: function(statusText) {
+				if ( callback ) {
+					callback(statusText);
+				}
+			}
+		};
+	}
+});
+
+// #5280: we need to abort on unload or IE will keep connections alive
+jQuery(window).bind( "unload" , function() {
+
+	// Abort all pending requests
+	jQuery.each(xhrs, function(_, xhr) {
+		if ( xhr.onreadystatechange ) {
+			xhr.onreadystatechange( xhrUnloadAbortMarker );
+		}
+	});
+
+	// Resest polling structure to be safe
+	xhrs = {};
+
+});
+
+})( jQuery );