|
|
@@ -0,0 +1,620 @@
|
|
|
+/**
|
|
|
+ * Wrapper for built-in http.js to emulate the browser XMLHttpRequest object.
|
|
|
+ *
|
|
|
+ * This can be used with JS designed for browsers to improve reuse of code and
|
|
|
+ * allow the use of existing libraries.
|
|
|
+ *
|
|
|
+ * Usage: include("XMLHttpRequest.js") and use XMLHttpRequest per W3C specs.
|
|
|
+ *
|
|
|
+ * @author Dan DeFelippi <dan@driverdan.com>
|
|
|
+ * @contributor David Ellis <d.f.ellis@ieee.org>
|
|
|
+ * @license MIT
|
|
|
+ */
|
|
|
+
|
|
|
+var Url = require("url");
|
|
|
+var spawn = require("child_process").spawn;
|
|
|
+var fs = require("fs");
|
|
|
+
|
|
|
+exports.XMLHttpRequest = function() {
|
|
|
+ "use strict";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Private variables
|
|
|
+ */
|
|
|
+ var self = this;
|
|
|
+ var http = require("http");
|
|
|
+ var https = require("https");
|
|
|
+
|
|
|
+ // Holds http.js objects
|
|
|
+ var request;
|
|
|
+ var response;
|
|
|
+
|
|
|
+ // Request settings
|
|
|
+ var settings = {};
|
|
|
+
|
|
|
+ // Disable header blacklist.
|
|
|
+ // Not part of XHR specs.
|
|
|
+ var disableHeaderCheck = false;
|
|
|
+
|
|
|
+ // Set some default headers
|
|
|
+ var defaultHeaders = {
|
|
|
+ "User-Agent": "node-XMLHttpRequest",
|
|
|
+ "Accept": "*/*",
|
|
|
+ };
|
|
|
+
|
|
|
+ var headers = {};
|
|
|
+ var headersCase = {};
|
|
|
+
|
|
|
+ // These headers are not user setable.
|
|
|
+ // The following are allowed but banned in the spec:
|
|
|
+ // * user-agent
|
|
|
+ var forbiddenRequestHeaders = [
|
|
|
+ "accept-charset",
|
|
|
+ "accept-encoding",
|
|
|
+ "access-control-request-headers",
|
|
|
+ "access-control-request-method",
|
|
|
+ "connection",
|
|
|
+ "content-length",
|
|
|
+ "content-transfer-encoding",
|
|
|
+ "cookie",
|
|
|
+ "cookie2",
|
|
|
+ "date",
|
|
|
+ "expect",
|
|
|
+ "host",
|
|
|
+ "keep-alive",
|
|
|
+ "origin",
|
|
|
+ "referer",
|
|
|
+ "te",
|
|
|
+ "trailer",
|
|
|
+ "transfer-encoding",
|
|
|
+ "upgrade",
|
|
|
+ "via"
|
|
|
+ ];
|
|
|
+
|
|
|
+ // These request methods are not allowed
|
|
|
+ var forbiddenRequestMethods = [
|
|
|
+ "TRACE",
|
|
|
+ "TRACK",
|
|
|
+ "CONNECT"
|
|
|
+ ];
|
|
|
+
|
|
|
+ // Send flag
|
|
|
+ var sendFlag = false;
|
|
|
+ // Error flag, used when errors occur or abort is called
|
|
|
+ var errorFlag = false;
|
|
|
+
|
|
|
+ // Event listeners
|
|
|
+ var listeners = {};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Constants
|
|
|
+ */
|
|
|
+
|
|
|
+ this.UNSENT = 0;
|
|
|
+ this.OPENED = 1;
|
|
|
+ this.HEADERS_RECEIVED = 2;
|
|
|
+ this.LOADING = 3;
|
|
|
+ this.DONE = 4;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Public vars
|
|
|
+ */
|
|
|
+
|
|
|
+ // Current state
|
|
|
+ this.readyState = this.UNSENT;
|
|
|
+
|
|
|
+ // default ready state change handler in case one is not set or is set late
|
|
|
+ this.onreadystatechange = null;
|
|
|
+
|
|
|
+ // Result & response
|
|
|
+ this.responseText = "";
|
|
|
+ this.responseXML = "";
|
|
|
+ this.status = null;
|
|
|
+ this.statusText = null;
|
|
|
+
|
|
|
+ // Whether cross-site Access-Control requests should be made using
|
|
|
+ // credentials such as cookies or authorization headers
|
|
|
+ this.withCredentials = false;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Private methods
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Check if the specified header is allowed.
|
|
|
+ *
|
|
|
+ * @param string header Header to validate
|
|
|
+ * @return boolean False if not allowed, otherwise true
|
|
|
+ */
|
|
|
+ var isAllowedHttpHeader = function(header) {
|
|
|
+ return disableHeaderCheck || (header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Check if the specified method is allowed.
|
|
|
+ *
|
|
|
+ * @param string method Request method to validate
|
|
|
+ * @return boolean False if not allowed, otherwise true
|
|
|
+ */
|
|
|
+ var isAllowedHttpMethod = function(method) {
|
|
|
+ return (method && forbiddenRequestMethods.indexOf(method) === -1);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Public methods
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Open the connection. Currently supports local server requests.
|
|
|
+ *
|
|
|
+ * @param string method Connection method (eg GET, POST)
|
|
|
+ * @param string url URL for the connection.
|
|
|
+ * @param boolean async Asynchronous connection. Default is true.
|
|
|
+ * @param string user Username for basic authentication (optional)
|
|
|
+ * @param string password Password for basic authentication (optional)
|
|
|
+ */
|
|
|
+ this.open = function(method, url, async, user, password) {
|
|
|
+ this.abort();
|
|
|
+ errorFlag = false;
|
|
|
+
|
|
|
+ // Check for valid request method
|
|
|
+ if (!isAllowedHttpMethod(method)) {
|
|
|
+ throw new Error("SecurityError: Request method not allowed");
|
|
|
+ }
|
|
|
+
|
|
|
+ settings = {
|
|
|
+ "method": method,
|
|
|
+ "url": url.toString(),
|
|
|
+ "async": (typeof async !== "boolean" ? true : async),
|
|
|
+ "user": user || null,
|
|
|
+ "password": password || null
|
|
|
+ };
|
|
|
+
|
|
|
+ setState(this.OPENED);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Disables or enables isAllowedHttpHeader() check the request. Enabled by default.
|
|
|
+ * This does not conform to the W3C spec.
|
|
|
+ *
|
|
|
+ * @param boolean state Enable or disable header checking.
|
|
|
+ */
|
|
|
+ this.setDisableHeaderCheck = function(state) {
|
|
|
+ disableHeaderCheck = state;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets a header for the request or appends the value if one is already set.
|
|
|
+ *
|
|
|
+ * @param string header Header name
|
|
|
+ * @param string value Header value
|
|
|
+ */
|
|
|
+ this.setRequestHeader = function(header, value) {
|
|
|
+ if (this.readyState !== this.OPENED) {
|
|
|
+ throw new Error("INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN");
|
|
|
+ }
|
|
|
+ if (!isAllowedHttpHeader(header)) {
|
|
|
+ console.warn("Refused to set unsafe header \"" + header + "\"");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (sendFlag) {
|
|
|
+ throw new Error("INVALID_STATE_ERR: send flag is true");
|
|
|
+ }
|
|
|
+ header = headersCase[header.toLowerCase()] || header;
|
|
|
+ headersCase[header.toLowerCase()] = header;
|
|
|
+ headers[header] = headers[header] ? headers[header] + ', ' + value : value;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Gets a header from the server response.
|
|
|
+ *
|
|
|
+ * @param string header Name of header to get.
|
|
|
+ * @return string Text of the header or null if it doesn't exist.
|
|
|
+ */
|
|
|
+ this.getResponseHeader = function(header) {
|
|
|
+ if (typeof header === "string"
|
|
|
+ && this.readyState > this.OPENED
|
|
|
+ && response
|
|
|
+ && response.headers
|
|
|
+ && response.headers[header.toLowerCase()]
|
|
|
+ && !errorFlag
|
|
|
+ ) {
|
|
|
+ return response.headers[header.toLowerCase()];
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Gets all the response headers.
|
|
|
+ *
|
|
|
+ * @return string A string with all response headers separated by CR+LF
|
|
|
+ */
|
|
|
+ this.getAllResponseHeaders = function() {
|
|
|
+ if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
|
|
|
+ return "";
|
|
|
+ }
|
|
|
+ var result = "";
|
|
|
+
|
|
|
+ for (var i in response.headers) {
|
|
|
+ // Cookie headers are excluded
|
|
|
+ if (i !== "set-cookie" && i !== "set-cookie2") {
|
|
|
+ result += i + ": " + response.headers[i] + "\r\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result.substr(0, result.length - 2);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Gets a request header
|
|
|
+ *
|
|
|
+ * @param string name Name of header to get
|
|
|
+ * @return string Returns the request header or empty string if not set
|
|
|
+ */
|
|
|
+ this.getRequestHeader = function(name) {
|
|
|
+ if (typeof name === "string" && headersCase[name.toLowerCase()]) {
|
|
|
+ return headers[headersCase[name.toLowerCase()]];
|
|
|
+ }
|
|
|
+
|
|
|
+ return "";
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sends the request to the server.
|
|
|
+ *
|
|
|
+ * @param string data Optional data to send as request body.
|
|
|
+ */
|
|
|
+ this.send = function(data) {
|
|
|
+ if (this.readyState !== this.OPENED) {
|
|
|
+ throw new Error("INVALID_STATE_ERR: connection must be opened before send() is called");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (sendFlag) {
|
|
|
+ throw new Error("INVALID_STATE_ERR: send has already been called");
|
|
|
+ }
|
|
|
+
|
|
|
+ var ssl = false, local = false;
|
|
|
+ var url = Url.parse(settings.url);
|
|
|
+ var host;
|
|
|
+ // Determine the server
|
|
|
+ switch (url.protocol) {
|
|
|
+ case "https:":
|
|
|
+ ssl = true;
|
|
|
+ // SSL & non-SSL both need host, no break here.
|
|
|
+ case "http:":
|
|
|
+ host = url.hostname;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case "file:":
|
|
|
+ local = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case undefined:
|
|
|
+ case null:
|
|
|
+ case "":
|
|
|
+ host = "localhost";
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ throw new Error("Protocol not supported.");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Load files off the local filesystem (file://)
|
|
|
+ if (local) {
|
|
|
+ if (settings.method !== "GET") {
|
|
|
+ throw new Error("XMLHttpRequest: Only GET method is supported");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (settings.async) {
|
|
|
+ fs.readFile(url.pathname, "utf8", function(error, data) {
|
|
|
+ if (error) {
|
|
|
+ self.handleError(error);
|
|
|
+ } else {
|
|
|
+ self.status = 200;
|
|
|
+ self.responseText = data;
|
|
|
+ setState(self.DONE);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ this.responseText = fs.readFileSync(url.pathname, "utf8");
|
|
|
+ this.status = 200;
|
|
|
+ setState(self.DONE);
|
|
|
+ } catch(e) {
|
|
|
+ this.handleError(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Default to port 80. If accessing localhost on another port be sure
|
|
|
+ // to use http://localhost:port/path
|
|
|
+ var port = url.port || (ssl ? 443 : 80);
|
|
|
+ // Add query string if one is used
|
|
|
+ var uri = url.pathname + (url.search ? url.search : "");
|
|
|
+
|
|
|
+ // Set the defaults if they haven't been set
|
|
|
+ for (var name in defaultHeaders) {
|
|
|
+ if (!headersCase[name.toLowerCase()]) {
|
|
|
+ headers[name] = defaultHeaders[name];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Set the Host header or the server may reject the request
|
|
|
+ headers.Host = host;
|
|
|
+ if (!((ssl && port === 443) || port === 80)) {
|
|
|
+ headers.Host += ":" + url.port;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Set Basic Auth if necessary
|
|
|
+ if (settings.user) {
|
|
|
+ if (typeof settings.password === "undefined") {
|
|
|
+ settings.password = "";
|
|
|
+ }
|
|
|
+ var authBuf = new Buffer(settings.user + ":" + settings.password);
|
|
|
+ headers.Authorization = "Basic " + authBuf.toString("base64");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Set content length header
|
|
|
+ if (settings.method === "GET" || settings.method === "HEAD") {
|
|
|
+ data = null;
|
|
|
+ } else if (data) {
|
|
|
+ headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
|
|
|
+
|
|
|
+ if (!headers["Content-Type"]) {
|
|
|
+ headers["Content-Type"] = "text/plain;charset=UTF-8";
|
|
|
+ }
|
|
|
+ } else if (settings.method === "POST") {
|
|
|
+ // For a post with no data set Content-Length: 0.
|
|
|
+ // This is required by buggy servers that don't meet the specs.
|
|
|
+ headers["Content-Length"] = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ var options = {
|
|
|
+ host: host,
|
|
|
+ port: port,
|
|
|
+ path: uri,
|
|
|
+ method: settings.method,
|
|
|
+ headers: headers,
|
|
|
+ agent: false,
|
|
|
+ withCredentials: self.withCredentials
|
|
|
+ };
|
|
|
+
|
|
|
+ // Reset error flag
|
|
|
+ errorFlag = false;
|
|
|
+
|
|
|
+ // Handle async requests
|
|
|
+ if (settings.async) {
|
|
|
+ // Use the proper protocol
|
|
|
+ var doRequest = ssl ? https.request : http.request;
|
|
|
+
|
|
|
+ // Request is being sent, set send flag
|
|
|
+ sendFlag = true;
|
|
|
+
|
|
|
+ // As per spec, this is called here for historical reasons.
|
|
|
+ self.dispatchEvent("readystatechange");
|
|
|
+
|
|
|
+ // Handler for the response
|
|
|
+ var responseHandler = function responseHandler(resp) {
|
|
|
+ // Set response var to the response we got back
|
|
|
+ // This is so it remains accessable outside this scope
|
|
|
+ response = resp;
|
|
|
+ // Check for redirect
|
|
|
+ // @TODO Prevent looped redirects
|
|
|
+ if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
|
|
|
+ // Change URL to the redirect location
|
|
|
+ settings.url = response.headers.location;
|
|
|
+ var url = Url.parse(settings.url);
|
|
|
+ // Set host var in case it's used later
|
|
|
+ host = url.hostname;
|
|
|
+ // Options for the new request
|
|
|
+ var newOptions = {
|
|
|
+ hostname: url.hostname,
|
|
|
+ port: url.port,
|
|
|
+ path: url.path,
|
|
|
+ method: response.statusCode === 303 ? "GET" : settings.method,
|
|
|
+ headers: headers,
|
|
|
+ withCredentials: self.withCredentials
|
|
|
+ };
|
|
|
+
|
|
|
+ // Issue the new request
|
|
|
+ request = doRequest(newOptions, responseHandler).on("error", errorHandler);
|
|
|
+ request.end();
|
|
|
+ // @TODO Check if an XHR event needs to be fired here
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ response.setEncoding("utf8");
|
|
|
+
|
|
|
+ setState(self.HEADERS_RECEIVED);
|
|
|
+ self.status = response.statusCode;
|
|
|
+
|
|
|
+ response.on("data", function(chunk) {
|
|
|
+ // Make sure there's some data
|
|
|
+ if (chunk) {
|
|
|
+ self.responseText += chunk;
|
|
|
+ }
|
|
|
+ // Don't emit state changes if the connection has been aborted.
|
|
|
+ if (sendFlag) {
|
|
|
+ setState(self.LOADING);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ response.on("end", function() {
|
|
|
+ if (sendFlag) {
|
|
|
+ // Discard the end event if the connection has been aborted
|
|
|
+ setState(self.DONE);
|
|
|
+ sendFlag = false;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ response.on("error", function(error) {
|
|
|
+ self.handleError(error);
|
|
|
+ });
|
|
|
+ };
|
|
|
+
|
|
|
+ // Error handler for the request
|
|
|
+ var errorHandler = function errorHandler(error) {
|
|
|
+ self.handleError(error);
|
|
|
+ };
|
|
|
+
|
|
|
+ // Create the request
|
|
|
+ request = doRequest(options, responseHandler).on("error", errorHandler);
|
|
|
+
|
|
|
+ // Node 0.4 and later won't accept empty data. Make sure it's needed.
|
|
|
+ if (data) {
|
|
|
+ request.write(data);
|
|
|
+ }
|
|
|
+
|
|
|
+ request.end();
|
|
|
+
|
|
|
+ self.dispatchEvent("loadstart");
|
|
|
+ } else { // Synchronous
|
|
|
+ // Create a temporary file for communication with the other Node process
|
|
|
+ var contentFile = ".node-xmlhttprequest-content-" + process.pid;
|
|
|
+ var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
|
|
|
+ fs.writeFileSync(syncFile, "", "utf8");
|
|
|
+ // The async request the other Node process executes
|
|
|
+ var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
|
|
|
+ + "var doRequest = http" + (ssl ? "s" : "") + ".request;"
|
|
|
+ + "var options = " + JSON.stringify(options) + ";"
|
|
|
+ + "var responseText = '';"
|
|
|
+ + "var req = doRequest(options, function(response) {"
|
|
|
+ + "response.setEncoding('utf8');"
|
|
|
+ + "response.on('data', function(chunk) {"
|
|
|
+ + " responseText += chunk;"
|
|
|
+ + "});"
|
|
|
+ + "response.on('end', function() {"
|
|
|
+ + "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText}}), 'utf8');"
|
|
|
+ + "fs.unlinkSync('" + syncFile + "');"
|
|
|
+ + "});"
|
|
|
+ + "response.on('error', function(error) {"
|
|
|
+ + "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');"
|
|
|
+ + "fs.unlinkSync('" + syncFile + "');"
|
|
|
+ + "});"
|
|
|
+ + "}).on('error', function(error) {"
|
|
|
+ + "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');"
|
|
|
+ + "fs.unlinkSync('" + syncFile + "');"
|
|
|
+ + "});"
|
|
|
+ + (data ? "req.write('" + JSON.stringify(data).slice(1,-1).replace(/'/g, "\\'") + "');":"")
|
|
|
+ + "req.end();";
|
|
|
+ // Start the other Node Process, executing this string
|
|
|
+ var syncProc = spawn(process.argv[0], ["-e", execString]);
|
|
|
+ while(fs.existsSync(syncFile)) {
|
|
|
+ // Wait while the sync file is empty
|
|
|
+ }
|
|
|
+ var resp = JSON.parse(fs.readFileSync(contentFile, 'utf8'));
|
|
|
+ // Kill the child process once the file has data
|
|
|
+ syncProc.stdin.end();
|
|
|
+ // Remove the temporary file
|
|
|
+ fs.unlinkSync(contentFile);
|
|
|
+
|
|
|
+ if (resp.err) {
|
|
|
+ self.handleError(resp.err);
|
|
|
+ } else {
|
|
|
+ response = resp.data;
|
|
|
+ self.status = resp.data.statusCode;
|
|
|
+ self.responseText = resp.data.text;
|
|
|
+ setState(self.DONE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Called when an error is encountered to deal with it.
|
|
|
+ */
|
|
|
+ this.handleError = function(error) {
|
|
|
+ this.status = 0;
|
|
|
+ this.statusText = error;
|
|
|
+ this.responseText = error.stack;
|
|
|
+ errorFlag = true;
|
|
|
+ setState(this.DONE);
|
|
|
+ this.dispatchEvent('error');
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Aborts a request.
|
|
|
+ */
|
|
|
+ this.abort = function() {
|
|
|
+ if (request) {
|
|
|
+ request.abort();
|
|
|
+ request = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ headers = defaultHeaders;
|
|
|
+ this.status = 0;
|
|
|
+ this.responseText = "";
|
|
|
+ this.responseXML = "";
|
|
|
+
|
|
|
+ errorFlag = true;
|
|
|
+
|
|
|
+ if (this.readyState !== this.UNSENT
|
|
|
+ && (this.readyState !== this.OPENED || sendFlag)
|
|
|
+ && this.readyState !== this.DONE) {
|
|
|
+ sendFlag = false;
|
|
|
+ setState(this.DONE);
|
|
|
+ }
|
|
|
+ this.readyState = this.UNSENT;
|
|
|
+ this.dispatchEvent('abort');
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Adds an event listener. Preferred method of binding to events.
|
|
|
+ */
|
|
|
+ this.addEventListener = function(event, callback) {
|
|
|
+ if (!(event in listeners)) {
|
|
|
+ listeners[event] = [];
|
|
|
+ }
|
|
|
+ // Currently allows duplicate callbacks. Should it?
|
|
|
+ listeners[event].push(callback);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Remove an event callback that has already been bound.
|
|
|
+ * Only works on the matching funciton, cannot be a copy.
|
|
|
+ */
|
|
|
+ this.removeEventListener = function(event, callback) {
|
|
|
+ if (event in listeners) {
|
|
|
+ // Filter will return a new array with the callback removed
|
|
|
+ listeners[event] = listeners[event].filter(function(ev) {
|
|
|
+ return ev !== callback;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Dispatch any events, including both "on" methods and events attached using addEventListener.
|
|
|
+ */
|
|
|
+ this.dispatchEvent = function(event) {
|
|
|
+ if (typeof self["on" + event] === "function") {
|
|
|
+ self["on" + event]();
|
|
|
+ }
|
|
|
+ if (event in listeners) {
|
|
|
+ for (var i = 0, len = listeners[event].length; i < len; i++) {
|
|
|
+ listeners[event][i].call(self);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Changes readyState and calls onreadystatechange.
|
|
|
+ *
|
|
|
+ * @param int state New state
|
|
|
+ */
|
|
|
+ var setState = function(state) {
|
|
|
+ if (state == self.LOADING || self.readyState !== state) {
|
|
|
+ self.readyState = state;
|
|
|
+
|
|
|
+ if (settings.async || self.readyState < self.OPENED || self.readyState === self.DONE) {
|
|
|
+ self.dispatchEvent("readystatechange");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (self.readyState === self.DONE && !errorFlag) {
|
|
|
+ self.dispatchEvent("load");
|
|
|
+ // @TODO figure out InspectorInstrumentation::didLoadXHR(cookie)
|
|
|
+ self.dispatchEvent("loadend");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+};
|
zhuzhuyule