Revert "Update all Angular libs (run update_all.sh)."

third_party/pkg/angular/lib/core_dom/http.dart

-part of angular.core.dom_internal;
+part of angular.core.dom;
 
-@Injectable()
+@NgInjectableService()
 class UrlRewriter {
   String call(url) => url;
 }
 
 /**
  * HTTP backend used by the [Http] service that delegates to dart:html's
  * [HttpRequest] and deals with Dart bugs.
  *
  * Never use this service directly, instead use the higher-level [Http].
  *
  * During testing this implementation is swapped with [MockHttpBackend] which
  * can be trained with responses.
  */
-@Injectable()
+@NgInjectableService()
 class HttpBackend {
   /**
    * Wrapper around dart:html's [HttpRequest.request]
    */
   async.Future request(String url,
       {String method, bool withCredentials, String responseType,
       String mimeType, Map<String, String> requestHeaders, sendData,
       void onProgress(dom.ProgressEvent e)}) =>
       dom.HttpRequest.request(url, method: method,
         withCredentials: withCredentials, responseType: responseType,
         mimeType: mimeType, requestHeaders: requestHeaders,
         sendData: sendData, onProgress: onProgress);
 }
 
-@Injectable()
+@NgInjectableService()
 class LocationWrapper {
   get location => dom.window.location;
 }
 
 typedef RequestInterceptor(HttpResponseConfig);
 typedef RequestErrorInterceptor(dynamic);
 typedef Response(HttpResponse);
 typedef ResponseError(dynamic);
 
 /**
@@ skipping 45 matching lines @@
     }
     return r;
   };
 
   Function requestError, responseError;
 }
 
 /**
  * A list of [HttpInterceptor]s.
  */
-@Injectable()
+@NgInjectableService()
 class HttpInterceptors {
   List<HttpInterceptor> _interceptors =
       [new DefaultTransformDataHttpInterceptor()];
 
   add(HttpInterceptor x) => _interceptors.add(x);
   addAll(List<HttpInterceptor> x) => _interceptors.addAll(x);
 
   /**
    * Called from [Http] to construct a [Future] chain.
    */
@@ skipping 118 matching lines @@
 
   /**
    * Useful for debugging.
    */
   toString() => 'HTTP $status: $data';
 }
 
 /**
  * Default header configuration.
  */
-@Injectable()
+@NgInjectableService()
 class HttpDefaultHeaders {
   static var _defaultContentType = 'application/json;charset=utf-8';
   var _headers = {
     'COMMON': {'Accept': 'application/json, text/plain, */*'},
     'POST' : {'Content-Type': _defaultContentType},
     'PUT' : {'Content-Type': _defaultContentType },
     'PATCH' : {'Content-Type': _defaultContentType}
   };
 
   _applyHeaders(method, ucHeaders, headers) {
@@ skipping 25 matching lines @@
   operator[](method) => _headers[method.toUpperCase()];
 }
 
 /**
 * Injected into the [Http] service.  This class contains application-wide
 * HTTP defaults.
 *
 * The default implementation provides headers which the
 * Angular team believes to be useful.
 */
-@Injectable()
+@NgInjectableService()
 class HttpDefaults {
   /**
    * The [HttpDefaultHeaders] object used by [Http] to add default headers
    * to requests.
    */
   HttpDefaultHeaders headers;
 
   /**
    * The default cache.  To enable caching application-wide, instantiate with a
    * [Cache] object.
@@ skipping 66 matching lines @@
  *
  * # Interceptors
  *
  * Http uses the interceptors from [HttpInterceptors]. You can also include
  * interceptors in the [call] method.
  *
  * # Security Considerations
  *
  * NOTE: < not yet documented >
  */
-@Injectable()
+@NgInjectableService()
 class Http {
   var _pendingRequests = <String, async.Future<HttpResponse>>{};
   BrowserCookies _cookies;
   LocationWrapper _location;
   UrlRewriter _rewriter;
   HttpBackend _backend;
   HttpInterceptors _interceptors;
 
   /**
    * The defaults for [Http]
    */
   HttpDefaults defaults;
 
   /**
    * Constructor, useful for DI.
    */
   Http(this._cookies, this._location, this._rewriter, this._backend,
        this.defaults, this._interceptors);
 
   /**
+   * DEPRECATED
+   */
+  async.Future<String> getString(String url, {bool withCredentials,
+      void onProgress(dom.ProgressEvent e), Cache cache}) =>
+      request(url,
+              withCredentials: withCredentials,
+              onProgress: onProgress,
+              cache: cache).then((HttpResponse xhr) => xhr.responseText);
+
+  /**
    * Parse a [requestUrl] and determine whether this is a same-origin request as
    * the application document.
    */
   bool _urlIsSameOrigin(String requestUrl) {
     Uri originUrl = Uri.parse(_location.location.toString());
     Uri parsed = originUrl.resolve(requestUrl);
     return (parsed.scheme == originUrl.scheme && parsed.host == originUrl.host);
   }
 
 /**
@@ skipping 13 matching lines @@
   * - xsrfCookieName: TBI
   * - interceptors: Either a [HttpInterceptor] or a [HttpInterceptors]
   * - cache: Boolean or [Cache].  If true, the default cache will be used.
   * - timeout: deprecated
 */
   async.Future<HttpResponse> call({
     String url,
     String method,
     data,
     Map<String, dynamic> params,
-    Map<String, dynamic> headers,
+    Map<String, String> headers,
     xsrfHeaderName,
     xsrfCookieName,
     interceptors,
     cache,
     timeout
   }) {
     if (timeout != null) {
       throw ['timeout not implemented'];
     }
 
-    url = _rewriter(url);
     method = method.toUpperCase();
 
     if (headers == null) headers = {};
     defaults.headers.setHeaders(headers, method);
 
     var xsrfValue = _urlIsSameOrigin(url) ?
         _cookies[xsrfCookieName != null ? xsrfCookieName : defaults.xsrfCookieName] :
         null;
     if (xsrfValue != null) {
       headers[xsrfHeaderName != null ? xsrfHeaderName : defaults.xsrfHeaderName]
           = xsrfValue;
     }
 
     // Check for functions in headers
     headers.forEach((k, v) {
       if (v is Function) headers[k] = v();
     });
 
     var serverRequest = (HttpResponseConfig config) {
-      assert(config.data == null || config.data is String || config.data is dom.File);
+      assert(config.data == null || config.data is String ||
+          config.data is dom.File);
 
       // Strip content-type if data is undefined
       if (config.data == null) {
         new List.from(headers.keys)
             .where((h) => h.toUpperCase() == 'CONTENT-TYPE')
             .forEach((h) => headers.remove(h));
       }
 
-      url = _buildUrl(config.url, config.params);
-
-      if (cache == false) {
-        cache = null;
-      } else if (cache == null) {
-        cache = defaults.cache;
-      }
-
-      // We return a pending request only if caching is enabled.
-      if (cache != null && _pendingRequests.containsKey(url)) {
-        return _pendingRequests[url];
-      }
-      var cachedResponse = (cache != null && method == 'GET') ? cache.get(url) : null;
-      if (cachedResponse != null) {
-        return new async.Future.value(new HttpResponse.copy(cachedResponse));
-      }
-
-      var result = _backend.request(url,
-                                    method: method,
-                                    requestHeaders: config.headers,
-                                    sendData: config.data).then((dom.HttpRequest value) {
-        // TODO: Uncomment after apps migrate off of this class.
-        // assert(value.status >= 200 && value.status < 300);
-
-        var response = new HttpResponse(value.status, value.responseText,
-            parseHeaders(value), config);
-
-        if (cache != null) cache.put(url, response);
-        _pendingRequests.remove(url);
-        return response;
-      }, onError: (error) {
-        if (error is! dom.ProgressEvent) throw error;
-        dom.ProgressEvent event = error;
-        _pendingRequests.remove(url);
-        dom.HttpRequest request = event.currentTarget;
-        return new async.Future.error(
-            new HttpResponse(request.status, request.response, parseHeaders(request), config));
-      });
-      return _pendingRequests[url] = result;
+      return request(null,
+                     config: config,
+                     method: method,
+                     sendData: config.data,
+                     requestHeaders: config.headers,
+                     cache: cache);
     };
 
     var chain = [[serverRequest, null]];
 
     var future = new async.Future.value(new HttpResponseConfig(
         url: url,
         params: params,
         headers: headers,
         data: data));
 
@@ skipping 135 matching lines @@
       if (i == -1) return;
       var key = line.substring(0, i).trim().toLowerCase();
 
       if (key.isNotEmpty) {
         var val = line.substring(i + 1).trim();
         parsed[key] = parsed.containsKey(key) ? "${parsed[key]}, $val" : val;
       }
     });
     return parsed;
   }
+
   /**
    * Returns an [Iterable] of [Future] [HttpResponse]s for the requests
    * that the [Http] service is currently waiting for.
    */
   Iterable<async.Future<HttpResponse> > get pendingRequests =>
       _pendingRequests.values;
 
+  /**
+   * DEPRECATED
+   */
+  async.Future<HttpResponse> request(String rawUrl,
+      { HttpResponseConfig config,
+        String method: 'GET',
+        bool withCredentials: false,
+        String responseType,
+        String mimeType,
+        Map<String, String> requestHeaders,
+        sendData,
+        void onProgress(dom.ProgressEvent e),
+        /*Cache<String, HttpResponse> or false*/ cache }) {
+    String url;
+
+    if (config == null) {
+      url = _rewriter(rawUrl);
+      config = new HttpResponseConfig(url: url);
+    } else {
+      url = _buildUrl(config.url, config.params);
+    }
+
+    if (cache == false) {
+      cache = null;
+    } else if (cache == null) {
+      cache = defaults.cache;
+    }
+    // We return a pending request only if caching is enabled.
+    if (cache != null && _pendingRequests.containsKey(url)) {
+      return _pendingRequests[url];
+    }
+    var cachedResponse = (cache != null && method == 'GET')
+        ? cache.get(url)
+        : null;
+    if (cachedResponse != null) {
+      return new async.Future.value(new HttpResponse.copy(cachedResponse));
+    }
+
+    var result = _backend.request(url,
+        method: method,
+        withCredentials: withCredentials,
+        responseType: responseType,
+        mimeType: mimeType,
+        requestHeaders: requestHeaders,
+        sendData: sendData,
+        onProgress: onProgress).then((dom.HttpRequest value) {
+      // TODO: Uncomment after apps migrate off of this class.
+      // assert(value.status >= 200 && value.status < 300);
+
+      var response = new HttpResponse(value.status, value.responseText,
+          parseHeaders(value), config);
+
+      if (cache != null) cache.put(url, response);
+      _pendingRequests.remove(url);
+      return response;
+    }, onError: (error) {
+      if (error is! dom.ProgressEvent) throw error;
+      dom.ProgressEvent event = error;
+      _pendingRequests.remove(url);
+      dom.HttpRequest request = event.currentTarget;
+      return new async.Future.error(
+          new HttpResponse(request.status, request.response,
+              parseHeaders(request), config));
+    });
+    return _pendingRequests[url] = result;
+  }
+
   _buildUrl(String url, Map<String, dynamic> params) {
     if (params == null) return url;
     var parts = [];
 
     new List.from(params.keys)..sort()..forEach((String key) {
       var value = params[key];
       if (value == null) return;
       if (value is! List) value = [value];
 
       value.forEach((v) {
         if (v is Map) v = JSON.encode(v);
         parts.add(_encodeUriQuery(key) + '=' + _encodeUriQuery("$v"));
       });
     });
     return url + ((url.indexOf('?') == -1) ? '?' : '&') + parts.join('&');
   }
 
   _encodeUriQuery(val, {bool pctEncodeSpaces: false}) =>
       Uri.encodeComponent(val)
           .replaceAll('%40', '@')
           .replaceAll('%3A', ':')
           .replaceAll('%24', r'$')
           .replaceAll('%2C', ',')
           .replaceAll('%20', pctEncodeSpaces ? '%20' : '+');
 }