Update all Angular libs (run update_all.sh).

third_party/pkg/angular/lib/mock/http_backend.dart

-part of angular.mock;
+library angular.mock.http_backend;
 
+import 'dart:async' as dart_async;
+import 'dart:convert' show JSON;
+import 'dart:html';
+
+import 'package:angular/angular.dart';
+import 'package:angular/utils.dart' as utils;
+
+
 class _MockXhr {
-  var $$method, $$url, $$async, $$reqHeaders, $$respHeaders;
+  var method, url, async, reqHeaders, respHeaders;
 
   void open(method, url, async) {
-    $$method = method;
-    $$url = url;
-    $$async = async;
-    $$reqHeaders = {};
-    $$respHeaders = {};
+    this.method = method;
+    this.url = url;
+    this.async = async;
+    reqHeaders = {};
+    respHeaders = {};
   }
 
-  var $$data;
+  var data;
 
   void send(data) {
-    $$data = data;
+    data = data;
   }
 
   void setRequestHeader(key, value) {
-    $$reqHeaders[key] = value;
+    reqHeaders[key] = value;
   }
 
   String getResponseHeader(name) {
     // the lookup must be case insensitive, that's why we try two quick
     // lookups and full scan at last
-    if ($$respHeaders.containsKey(name)) return $$respHeaders[name];
+    if (respHeaders.containsKey(name)) return respHeaders[name];
 
     name = name.toLowerCase();
-    if ($$respHeaders.containsKey(name)) return $$respHeaders[name];
+    if (respHeaders.containsKey(name)) return respHeaders[name];
 
     String header = null;
-    $$respHeaders.forEach((headerName, headerVal) {
+    respHeaders.forEach((headerName, headerVal) {
       if (header != null) return;
       if (headerName.toLowerCase()) header = headerVal;
     });
     return header;
   }
 
   getAllResponseHeaders() {
-    if ($$respHeaders == null) return '';
+    if (respHeaders == null) return '';
 
     var lines = [];
 
-    $$respHeaders.forEach((key, value) {
+    respHeaders.forEach((key, value) {
       lines.add("$key: $value");
     });
     return lines.join('\n');
   }
 
   // noop
   abort() {}
 }
 
 /**
@@ skipping 106 matching lines @@
 
     var prettyPrint = (data) {
       return (data is String || data is Function || data is RegExp)
           ? data
           : JSON.encode(data);
     };
 
     var wrapResponse = (wrapped) {
       var handleResponse = () {
         var response = wrapped.response(method, url, data, headers);
-        xhr.$$respHeaders = response[2];
+        xhr.respHeaders = response[2];
         utils.relaxFnApply(callback, [response[0], response[1],
              xhr.getAllResponseHeaders()]);
       };
 
       var handleTimeout = () {
         for (var i = 0; i < responses.length; i++) {
           if (identical(responses[i], handleResponse)) {
             responses.removeAt(i);
             callback(-1, null, '');
             break;
@@ skipping 62 matching lines @@
         chain = new _Chain(respond: (status, data, headers) {
           definition.response = _createResponse(status, data, headers);
         });
 
     definitions.add(definition);
     return chain;
   }
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#whenGET
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#whenGET
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new backend definition for GET requests. For more info see `when()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(Object|function(Object))=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    * request is handled.
    */
   _Chain whenGET(url, [headers]) => when('GET', url, null, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#whenDELETE
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#whenDELETE
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new backend definition for DELETE requests. For more info see `when()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(Object|function(Object))=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    * request is handled.
    */
   _Chain whenDELETE(url, [headers]) => when('DELETE', url, null, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#whenJSONP
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#whenJSONP
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new backend definition for JSONP requests. For more info see `when()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    * request is handled.
    */
   _Chain whenJSONP(url, [headers]) => when('JSONP', url, null, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#whenPUT
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#whenPUT
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new backend definition for PUT requests.  For more info see `when()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(string|RegExp)=} data HTTP request body.
    * @param {(Object|function(Object))=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    * request is handled.
    */
   _Chain whenPUT(url, [data, headers]) => when('PUT', url, data, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#whenPOST
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#whenPOST
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new backend definition for POST requests. For more info see `when()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(string|RegExp)=} data HTTP request body.
    * @param {(Object|function(Object))=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    * request is handled.
    */
   _Chain whenPOST(url, [data, headers]) => when('POST', url, data, headers);
 
   _Chain whenPATCH(url, [data, headers]) => when('PATCH', url, data, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#whenHEAD
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#whenHEAD
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new backend definition for HEAD requests. For more info see `when()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(Object|function(Object))=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    * request is handled.
    */
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expect
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expect
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation.
    *
    * @param {string} method HTTP method.
    * @param {string|RegExp} url HTTP url.
    * @param {(string|RegExp)=} data HTTP request body.
    * @param {(Object|function(Object))=} headers HTTP headers or function that receives http header
    *   object and returns true if the headers match the current expectation.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    *  request is handled.
    *
    *  - respond – `{function([status,] data[, headers])|function(function(method, url, data, headers)}`
    *    – The respond method takes a set of static data to be returned or a function that can return
    *    an array containing response status (number), response data (string) and response headers
    *    (Object).
    */
   _Chain expect(method, [url, data, headers]) {
     var expectation = new MockHttpExpectation(method, url, data, headers);
     expectations.add(expectation);
     return new _Chain(respond: (status, data, headers) {
       expectation.response = _createResponse(status, data, headers);
     });
   }
 
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expectGET
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expectGET
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation for GET requests. For more info see `expect()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {Object=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    * request is handled. See #expect for more info.
    */
   _Chain expectGET(url, [headers]) => expect('GET', url, null, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expectDELETE
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expectDELETE
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation for DELETE requests. For more info see `expect()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {Object=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    *   request is handled.
    */
   _Chain expectDELETE(url, [headers]) => expect('DELETE', url, null, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expectJSONP
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expectJSONP
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation for JSONP requests. For more info see `expect()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    *   request is handled.
    */
   _Chain expectJSONP(url, [headers]) => expect('JSONP', url, null, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expectPUT
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expectPUT
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation for PUT requests. For more info see `expect()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(string|RegExp)=} data HTTP request body.
    * @param {Object=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    *   request is handled.
    */
   _Chain expectPUT(url, [data, headers]) => expect('PUT', url, data, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expectPOST
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expectPOST
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation for POST requests. For more info see `expect()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(string|RegExp)=} data HTTP request body.
    * @param {Object=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    *   request is handled.
    */
   _Chain expectPOST(url, [data, headers]) => expect('POST', url, data, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expectPATCH
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expectPATCH
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation for PATCH requests. For more info see `expect()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {(string|RegExp)=} data HTTP request body.
    * @param {Object=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    *   request is handled.
    */
   _Chain expectPATCH(url, [data, headers]) => expect('PATCH', url, data, headers);
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#expectHEAD
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#expectHEAD
+   * @methodOf ngMock.httpBackend
    * @description
    * Creates a new request expectation for HEAD requests. For more info see `expect()`.
    *
    * @param {string|RegExp} url HTTP url.
    * @param {Object=} headers HTTP headers.
    * @returns {requestHandler} Returns an object with `respond` method that control how a matched
    *   request is handled.
    */
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#flush
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#flush
+   * @methodOf ngMock.httpBackend
    * @description
    * Flushes all pending requests using the trained responses.
    *
    * @param {number=} count Number of responses to flush (in the order they arrived). If undefined,
    *   all pending requests will be flushed. If there are no pending requests when the flush method
    *   is called an exception is thrown (as this typically a sign of programming error).
    */
   void flush([count]) {
     if (responses.isEmpty) throw ['No pending request to flush !'];
 
     if (count != null) {
       while (count-- > 0) {
         if (responses.isEmpty) throw ['No more pending request to flush !'];
         responses.removeAt(0)();
       }
     } else {
       while (!responses.isEmpty) {
         responses.removeAt(0)();
       }
     }
     verifyNoOutstandingExpectation();
   }
 
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#verifyNoOutstandingExpectation
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#verifyNoOutstandingExpectation
+   * @methodOf ngMock.httpBackend
    * @description
    * Verifies that all of the requests defined via the `expect` api were made. If any of the
    * requests were not made, verifyNoOutstandingExpectation throws an exception.
    *
    * Typically, you would call this method following each test case that asserts requests using an
    * "afterEach" clause.
    *
    * <pre>
-   *   afterEach($httpBackend.verifyNoOutstandingExpectation);
+   *   afterEach(httpBackend.verifyNoOutstandingExpectation);
    * </pre>
    */
   void verifyNoOutstandingExpectation() {
     if (!expectations.isEmpty) {
       throw ['Unsatisfied requests: ${expectations.join(', ')}'];
     }
   }
 
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#verifyNoOutstandingRequest
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#verifyNoOutstandingRequest
+   * @methodOf ngMock.httpBackend
    * @description
    * Verifies that there are no outstanding requests that need to be flushed.
    *
    * Typically, you would call this method following each test case that asserts requests using an
    * "afterEach" clause.
    *
    * <pre>
-   *   afterEach($httpBackend.verifyNoOutstandingRequest);
+   *   afterEach(httpBackend.verifyNoOutstandingRequest);
    * </pre>
    */
   void verifyNoOutstandingRequest() {
     if (!responses.isEmpty) throw ['Unflushed requests: ${responses.length}'];
   }
 
 
   /**
    * @ngdoc method
-   * @name ngMock.$httpBackend#resetExpectations
-   * @methodOf ngMock.$httpBackend
+   * @name ngMock.httpBackend#resetExpectations
+   * @methodOf ngMock.httpBackend
    * @description
    * Resets all request expectations, but preserves all backend definitions. Typically, you would
    * call resetExpectations during a multiple-phase test when you want to reuse the same instance of
-   * $httpBackend mock.
+   * httpBackend mock.
    */
   void resetExpectations() {
     expectations.length = 0;
     responses.length = 0;
   }
 }
 
 /**
  * Mock implementation of the [HttpRequest] object returned from the HttpBackend.
  */
@@ skipping 64 matching lines @@
   final String type = null;
 
   bool cancelBubble = false;
 
   MockProgressEvent(MockHttpRequest this.currentTarget);
 
   void preventDefault() {}
   void stopImmediatePropagation() {}
   void stopPropagation() {}
 }