Add POST support to XHR as well as .status and statusText support

sky/framework/xmlhttprequest.sky

 <import src="/mojo/public/sky/core.sky" as="core" />
 <import src="/mojo/public/sky/unicode.sky" as="unicode" />
 <import src="/mojo/services/network/public/interfaces/network_service.mojom.sky" as="net" />
 <import src="/mojo/services/network/public/interfaces/url_loader.mojom.sky" as="loader" />
 <import src="/sky/framework/shell.sky" as="shell" />
 <script>
 // XHR keeps itself alive.
 var outstandingRequests = new Set();
 
 const kPrivate = Symbol("XMLHttpRequestPrivate");
 
 class Private {
   constructor() {
     this.networkService = shell.connectToService(
       "mojo:network_service", net.NetworkService);
     this.request = null;
     this.loader = null;
     this.headers = new Map();
     this.responseArrayBuffer = null;
     this.responseText = null; // Cached to avoid re-decoding each access.
   }
 }
 
+// Somewhat hacky, but works.
+function stringToUTF8Buffer(string) {
+    var string = unescape(encodeURIComponent(string));
+    var charList = string.split('');
+    var uintArray = [];
+    for (var i = 0; i < charList.length; i++) {
+        uintArray.push(charList[i].charCodeAt(0));

[esprehn, 2014/12/15 21:43:22]

This doesn't make sense, the splitting above seems to be trying to deal with
multi part unicode points, but charCodeAt will only ever return one part anyway.
You either want to use codePointAt() or just iterate the string here.

The unescape(encodeURIComponent trick is also weird, not sure what this is
doing. I don't think you need it.

[esprehn, 2014/12/15 21:50:56]

I think you want:

function stringToUTF8Buffer(string) {
    var buffer = new Uint8Array(string.length);
    for (var i = 0; i < string.length; i++) {
        buffer[i] = string.charCodeAt(i);
    }
    return buffer;
}

I think you use charCodeAt() since it's a uint8 array, so we need to split the
multi part unicode chars.

+    }
+    return new Uint8Array(uintArray);
+}
+
 // https://xhr.spec.whatwg.org
 class XMLHttpRequest {
   constructor() {
     this[kPrivate] = new Private;
     this.responseType = ''; // Only text and arraybuffer support for now.
+    this.status = null;
+    this.statusText = null;
   }
 
   onload() {
   }
 
   onerror(error) {
   }
 
   get responseText() {
     if (this.responseType !== '' && this.responseType !== 'text')
@@ skipping 23 matching lines @@
 
     var priv = this[kPrivate];
     priv.request = request;
     priv.headers.clear();
   }
 
   setRequestHeader(header, value) {
     this[kPrivate].headers.set(header, value);
   }
 
-  send() {
+  send(body) {
     var priv = this[kPrivate];
+    // Handle the body before the headers as it can affect Content-Type.
+    if (body) {
+      var bodyAsBufferView = null;
+      if (typeof(body) === "string") {
+        this.setRequestHeader("Content-Type", "text/plain;charset=UTF-8");
+        bodyAsBufferView = stringToUTF8Buffer(body);
+      } else {
+        bodyAsBufferView = new Uint8Array(body);
+      }
+      var dataPipe = new core.createDataPipe();
+      // FIXME: body is currently assumed to be an ArrayBuffer.
+      var writeResult = core.writeData(dataPipe.producerHandle,
+        bodyAsBufferView, core.WRITE_DATA_FLAG_ALL_OR_NONE);
+      core.close(dataPipe.producerHandle);
+      // FIXME: Much better error handling needed.
+      console.assert(writeResult.result === core.RESULT_OK);
+      console.assert(writeResult.numBytes === body.length);
+      // 'body' is actually an array of body segments.
+      priv.request.body = [dataPipe.consumerHandle];
+    }
+
     var requestHeaders = [];
     priv.headers.forEach(function(value, key) {
       requestHeaders.push(key + ': ' + value);
     });
     priv.request.headers = requestHeaders;
 
     // FIXME: Factor this into the JS bindings.
     var pipe = new core.createMessagePipe();
     priv.networkService.createURLLoader(pipe.handle1);
     priv.loader = shell.wrapHandle(pipe.handle0, loader.URLLoader);
 
     var self = this;
     outstandingRequests.add(this);
     priv.loader.start(priv.request).then(function(result) {
+      self.status = result.response.status_code;
+      self.statusText = result.response.status_line;
+      if (result.response.error)
+        throw new Error(result.response.error.description);
       return core.drainData(result.response.body).then(function(result) {
         outstandingRequests.delete(self);
         priv.responseArrayBuffer = result.buffer;
-        // FIXME: Catch exceptions during onload so they don't trip onerror.
-        self.onload();
+        // Use a setTimeout to avoid exceptions in onload tripping onerror.
+        window.setTimeout(function() {
+          self.onload();
+        });
       });
     }).catch(function(error) {
       outstandingRequests.delete(self);
+      // Technically this should throw a ProgressEvent.
       self.onerror(error);
     });
   }
 }
 
 module.exports = XMLHttpRequest;
 </script>