Reapply zone tasks.

tools/dom/templates/html/impl/impl_XMLHttpRequest.darttemplate

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of $LIBRARYNAME;
 
+/**
+ * A task specification for HTTP requests.
+ *
+ * This specification is not available when an HTTP request is sent through
+ * direct use of [HttpRequest.send]. See [HttpRequestSendTaskSpecification].
+ *
+ * A task created from this specification is a `Future<HttpRequest>`.
+ *
+ * *Experimental*. This class may disappear without notice.
+ */
+class HttpRequestTaskSpecification extends TaskSpecification {
+  /// The URL of the request.
+  final String url;
+
+  /// The HTTP request method.
+  ///
+  /// By default (when `null`) this is a `"GET"` request. Alternatively, the
+  /// method can be `"POST"`, `"PUT"`, `"DELETE"`, etc.
+  final String method;
+
+  /// Whether the request should send credentials. Credentials are only useful
+  /// for cross-origin requests.
+  ///
+  /// See [HttpRequest.request] for more information.
+  final bool withCredentials;
+
+  /// The desired response format.
+  ///
+  /// Supported types are:
+  /// - `""`: (same as `"text"`),
+  /// - `"arraybuffer"`,
+  /// - `"blob"`,
+  /// - `"document"`,
+  /// - `"json"`,
+  /// - `"text"`
+  ///
+  /// When no value is provided (when equal to `null`) defaults to `""`.
+  final String responseType;
+
+  /// The desired MIME type.
+  ///
+  /// This overrides the default MIME type which is set up to transfer textual
+  /// data.
+  final String mimeType;
+
+  /// The request headers that should be sent with the request.
+  final Map<String, String> requestHeaders;
+
+  /// The data that is sent with the request.
+  ///
+  /// When data is provided (the value is not `null`), it must be a
+  /// [ByteBuffer], [Blob], [Document], [String], or [FormData].
+  final dynamic sendData;
+
+  /// The function that is invoked on progress updates. This function is
+  /// registered as an event listener on the created [HttpRequest] object, and
+  /// thus has its own task. Further invocations of the progress function do
+  /// *not* use the HTTP request task as task object.
+  ///
+  /// Creating an HTTP request automatically registers the on-progress listener.
+  final ZoneUnaryCallback<dynamic, ProgressEvent> onProgress;
+
+  HttpRequestTaskSpecification(this.url,
+      {String this.method, bool this.withCredentials, String this.responseType,
+      String this.mimeType, Map<String, String> this.requestHeaders,
+      this.sendData,
+      void this.onProgress(ProgressEvent e)});
+
+  String get name => "dart.html.http-request";
+  bool get isOneShot => true;
+}
+
+/**
+ * A task specification for HTTP requests that are initiated through a direct
+ * invocation of [HttpRequest.send].
+ *
+ * This specification serves as signal to zones that an HTTP request has been
+ * initiated. The created task is the [request] object itself, and
+ * no callback is ever executed in this task.
+ *
+ * Note that event listeners on the HTTP request are also registered in the
+ * zone (although with their own task creations), and that a zone can thus
+ * detect when the HTTP request returns.
+ *
+ * HTTP requests that are initiated through `request` methods don't use
+ * this class but use [HttpRequestTaskSpecification].
+ *
+ * *Experimental*. This class may disappear without notice.
+ */
+class HttpRequestSendTaskSpecification extends TaskSpecification {
+  final HttpRequest request;
+  final dynamic sendData;
+
+  HttpRequestSendTaskSpecification(this.request, this.sendData);
+
+  String get name => "dart.html.http-request-send";
+
+  /**
+   * No callback is ever executed in an HTTP request send task.
+   */
+  bool get isOneShot => false;
+}
+
  /**
   * A client-side XHR request for getting data from a URL,
   * formally known as XMLHttpRequest.
   *
   * HttpRequest can be used to obtain data from HTTP and FTP protocols,
   * and is useful for AJAX-style page updates.
   *
   * The simplest way to get the contents of a text file, such as a
   * JSON-formatted file, is with [getString].
   * For example, the following code gets the contents of a JSON file
@@ skipping 166 matching lines @@
    * with appropriate permissions in their manifest. Requests to file:// URIs
    * will also never fail- the Future will always complete successfully, even
    * when the file cannot be found.
    *
    * See also: [authorization headers](http://en.wikipedia.org/wiki/Basic_access_authentication).
    */
   static Future<HttpRequest> request(String url,
       {String method, bool withCredentials, String responseType,
       String mimeType, Map<String, String> requestHeaders, sendData,
       void onProgress(ProgressEvent e)}) {
+    var spec = new HttpRequestTaskSpecification(
+        url, method: method,
+        withCredentials: withCredentials,
+        responseType: responseType,
+        mimeType: mimeType,
+        requestHeaders: requestHeaders,
+        sendData: sendData,
+        onProgress: onProgress);
+
+    if (identical(Zone.current, Zone.ROOT)) {
+      return _createHttpRequestTask(spec, null);
+    }
+    return Zone.current.createTask(_createHttpRequestTask, spec);
+  }
+
+  static Future<HttpRequest> _createHttpRequestTask(
+      HttpRequestTaskSpecification spec, Zone zone) {
+    String url = spec.url;
+    String method = spec.method;
+    bool withCredentials = spec.withCredentials;
+    String responseType = spec.responseType;
+    String mimeType = spec.mimeType;
+    Map<String, String> requestHeaders = spec.requestHeaders;
+    var sendData = spec.sendData;
+    var onProgress = spec.onProgress;
+
     var completer = new Completer<HttpRequest>();
+    var task = completer.future;
 
     var xhr = new HttpRequest();
     if (method == null) {
       method = 'GET';
     }
     xhr.open(method, url, async: true);
 
     if (withCredentials != null) {
       xhr.withCredentials = withCredentials;
     }
@@ skipping 19 matching lines @@
     xhr.onLoad.listen((e) {
       var accepted = xhr.status >= 200 && xhr.status < 300;
       var fileUri = xhr.status == 0; // file:// URIs have status of 0.
       var notModified = xhr.status == 304;
       // Redirect status is specified up to 307, but others have been used in
       // practice. Notably Google Drive uses 308 Resume Incomplete for
       // resumable uploads, and it's also been used as a redirect. The
       // redirect case will be handled by the browser before it gets to us,
       // so if we see it we should pass it through to the user.
       var unknownRedirect = xhr.status > 307 && xhr.status < 400;
-      
-      if (accepted || fileUri || notModified || unknownRedirect) {
+
+      var isSuccessful = accepted || fileUri || notModified || unknownRedirect;
+
+      if (zone == null && isSuccessful) {
         completer.complete(xhr);
+      } else if (zone == null) {
+        completer.completeError(e);
+      } else if (isSuccessful) {
+        zone.runTask((task, value) {
+          completer.complete(value);
+        }, task, xhr);
       } else {
-        completer.completeError(e);
+        zone.runTask((task, error) {
+          completer.completeError(error);
+        }, task, e);
       }
     });
 
-    xhr.onError.listen(completer.completeError);
+    if (zone == null) {
+      xhr.onError.listen(completer.completeError);
+    } else {
+      xhr.onError.listen((error) {
+        zone.runTask((task, error) {
+          completer.completeError(error);
+        }, task, error);
+      });
+    }
 
     if (sendData != null) {
-      xhr.send(sendData);
+      // TODO(floitsch): should we go through 'send()' and have nested tasks?
+      xhr._send(sendData);
     } else {
-      xhr.send();
+      xhr._send();
     }
 
-    return completer.future;
+    return task;
   }
 
   /**
    * Checks to see if the Progress event is supported on the current platform.
    */
   static bool get supportsProgressEvent {
 $if DART2JS
     var xhr = new HttpRequest();
     return JS('bool', '("onprogress" in #)', xhr);
 $else
@@ skipping 49 matching lines @@
    * cross-origin support is not required then [request] should be used instead.
    */
   @Experimental()
   static Future<String> requestCrossOrigin(String url,
       {String method, String sendData}) {
     if (supportsCrossOrigin) {
       return request(url, method: method, sendData: sendData).then((xhr) {
         return xhr.responseText;
       });
     }
+    // TODO(floitsch): the following code doesn't go through task zones.
+    // Since 'XDomainRequest' is an IE9 feature we should probably just remove
+    // it.
 $if DART2JS
     var completer = new Completer<String>();
     if (method == null) {
       method = 'GET';
     }
     var xhr = JS('var', 'new XDomainRequest()');
     JS('', '#.open(#, #)', xhr, method, url);
     JS('', '#.onload = #', xhr, convertDartClosureToJS((e) {
       var response = JS('String', '#.responseText', xhr);
       completer.complete(response);
@@ skipping 60 matching lines @@
    *
    * By default the request is done asyncronously, with no user or password
    * authentication information. If `async` is false, the request will be send
    * synchronously.
    *
    * Calling `open` again on a currently active request is equivalent to
    * calling `abort`.
    *
    * Note: Most simple HTTP requests can be accomplished using the [getString],
    * [request], [requestCrossOrigin], or [postFormData] methods. Use of this
-   * `open` method is intended only for more complext HTTP requests where
+   * `open` method is intended only for more complex HTTP requests where
    * finer-grained control is needed.
    */
   @DomName('XMLHttpRequest.open')
   @DocsEditable()
 $if JSINTEROP
   void open(String method, String url, {bool async, String user, String password}) {
     if (async == null && user == null && password == null) {
       _blink.BlinkXMLHttpRequest.instance.open_Callback_2_(this, method, url);
     } else {
       _blink.BlinkXMLHttpRequest.instance.open_Callback_5_(this, method, url, async, user, password);
     }
   }
 $else
   void open(String method, String url, {bool async, String user, String password}) native;
 $endif
 
+  /**
+   * Sends the request with any given `data`.
+   *
+   * Note: Most simple HTTP requests can be accomplished using the [getString],
+   * [request], [requestCrossOrigin], or [postFormData] methods. Use of this
+   * `send` method is intended only for more complex HTTP requests where
+   * finer-grained control is needed.
+   *
+   * ## Other resources
+   *
+   * * [XMLHttpRequest.send](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#send%28%29)
+   *   from MDN.
+   */
+  @DomName('XMLHttpRequest.send')
+  @DocsEditable()
+  void send([body_OR_data]) {
+    if (identical(Zone.current, Zone.ROOT)) {
+      _send(body_OR_data);
+    } else {
+      Zone.current.createTask(_createHttpRequestSendTask,
+          new HttpRequestSendTaskSpecification(this, body_OR_data));
+    }
+  }
+
+  static HttpRequest _createHttpRequestSendTask(
+      HttpRequestSendTaskSpecification spec, Zone zone) {
+    spec.request._send(spec.sendData);
+    return spec.request;
+  }
+
 $!MEMBERS
 }