Update Polymer components and re-run reproduce.sh

third_party/polymer/v1_0/components/iron-ajax/iron-ajax.html

 <!--
 Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
 This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
 The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
 The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
 
 <link rel="import" href="../polymer/polymer.html">
@@ skipping 12 matching lines @@
 
 With `auto` set to `true`, the element performs a request whenever
 its `url`, `params` or `body` properties are changed. Automatically generated
 requests will be debounced in the case that multiple attributes are changed
 sequentially.
 
 Note: The `params` attribute must be double quoted JSON.
 
 You can trigger a request explicitly by calling `generateRequest` on the
 element.
+
+@demo demo/index.html
 -->
 
 <script>
 
   Polymer({
 
     is: 'iron-ajax',
 
     /**
      * Fired when a request is sent.
@@ skipping 17 matching lines @@
       /**
        * The URL target of the request.
        */
       url: {
         type: String,
         value: ''
       },
 
       /**
        * An object that contains query parameters to be appended to the
-       * specified `url` when generating a request.
+       * specified `url` when generating a request. If you wish to set the body
+       * content when making a POST request, you should use the `body` property
+       * instead.
        */
       params: {
         type: Object,
         value: function() {
           return {};
         }
       },
 
       /**
        * The HTTP method to use such as 'GET', 'POST', 'PUT', or 'DELETE'.
        * Default is 'GET'.
        */
       method: {
         type: String,
         value: 'GET'
       },
 
       /**
        * HTTP request headers to send.
        *
        * Example:
        *
        *     <iron-ajax
        *         auto
        *         url="http://somesite.com"
        *         headers='{"X-Requested-With": "XMLHttpRequest"}'
        *         handle-as="json"
        *         last-response-changed="{{handleResponse}}"></iron-ajax>
+       *
+       * Note: setting a `Content-Type` header here will override the value
+       * specified by the `contentType` property of this element.
        */
       headers: {
         type: Object,
         value: function() {
           return {};
         }
       },
 
       /**
-       * Content type to use when sending data. If the contenttype is set
-       * and a `Content-Type` header is specified in the `headers` attribute,
-       * the `headers` attribute value will take precedence.
+       * Content type to use when sending data. If the `contentType` property
+       * is set and a `Content-Type` header is specified in the `headers`
+       * property, the `headers` property value will take precedence.
        */
       contentType: {
         type: String,
         value: 'application/x-www-form-urlencoded'
       },
 
       /**
        * Optional raw body content to send when method === "POST".
        *
        * Example:
@@ skipping 79 matching lines @@
        */
       lastRequest: {
         type: Object,
         notify: true,
         readOnly: true
       },
 
       /**
        * Will be set to the most recent response received by a request
        * that originated from this iron-ajax element. The type of the response
-       * is determined by the value of `handleas` at the time that the request
+       * is determined by the value of `handleAs` at the time that the request
        * was generated.
        */
       lastResponse: {
         type: Object,
         notify: true,
         readOnly: true
       },
 
       /**
        * Will be set to the most recent error that resulted from a request
        * that originated from this iron-ajax element.
        */
       lastError: {
         type: Object,
         notify: true,
         readOnly: true
       },
 
       /**
        * An Array of all in-flight requests originating from this iron-ajax
        * element.
        */
       activeRequests: {
         type: Array,
         notify: true,
         readOnly: true,
         value: function() {
-          this._setActiveRequests([]);
+          return [];
         }
       },
 
       /**
        * Length of time in milliseconds to debounce multiple requests.
        */
       debounceDuration: {
         type: Number,
         value: 0,
         notify: true
       },
 
       _boundHandleResponse: {
         type: Function,
         value: function() {
-          return this.handleResponse.bind(this);
-        }
-      },
-
-      _boundDiscardRequest: {
-        type: Function,
-        value: function() {
-          return this.discardRequest.bind(this);
+          return this._handleResponse.bind(this);
         }
       }
     },
 
     observers: [
-      'requestOptionsChanged(url, method, params, headers,' +
+      '_requestOptionsChanged(url, method, params, headers,' +
         'contentType, body, sync, handleAs, withCredentials, auto)'
     ],
 
+    /**
+     * The query string that should be appended to the `url`, serialized from
+     * the current value of `params`.
+     *
+     * @return {string}
+     */
     get queryString () {
       var queryParts = [];
       var param;
       var value;
 
       for (param in this.params) {
         value = this.params[param];
         param = window.encodeURIComponent(param);
 
         if (value !== null) {
           param += '=' + window.encodeURIComponent(value);
         }
 
         queryParts.push(param);
       }
 
       return queryParts.join('&');
     },
 
+    /**
+     * The `url` with query string (if `params` are specified), suitable for
+     * providing to an `iron-request` instance.
+     *
+     * @return {string}
+     */
     get requestUrl() {
       var queryString = this.queryString;
 
       if (queryString) {
         return this.url + '?' + queryString;
       }
 
       return this.url;
     },
 
+    /**
+     * An object that maps header names to header values, first applying the
+     * the value of `Content-Type` and then overlaying the headers specified
+     * in the `headers` property.
+     *
+     * @return {Object}
+     */
     get requestHeaders() {
       var headers = {
-        'content-type': this.contentType
+        'Content-Type': this.contentType
       };
       var header;
 
       if (this.headers instanceof Object) {
         for (header in this.headers) {
           headers[header] = this.headers[header].toString();
         }
       }
 
       return headers;
     },
 
+    /**
+     * Request options suitable for generating an `iron-request` instance based
+     * on the current state of the `iron-ajax` instance's properties.
+     *
+     * @return {{
+     *   url: string,
+     *   method: (string|undefined),
+     *   async: (boolean|undefined),
+     *   body: (ArrayBuffer|ArrayBufferView|Blob|Document|FormData|null|string|undefined),
+     *   headers: (Object|undefined),
+     *   handleAs: (string|undefined),
+     *   withCredentials: (boolean|undefined)}}
+     */
     toRequestOptions: function() {
       return {
         url: this.requestUrl,
         method: this.method,
         headers: this.requestHeaders,
         body: this.body,
         async: !this.sync,
         handleAs: this.handleAs,
         withCredentials: this.withCredentials
       };
     },
 
-    requestOptionsChanged: function() {
-      this.debounce('generate-request', function() {
-        if (!this.url && this.url !== '') {
-          return;
-        }
-
-        if (this.auto) {
-          this.generateRequest();
-        }
-      }, this.debounceDuration);
-    },
-
     /**
      * Performs an AJAX request to the specified URL.
      *
-     * @method generateRequest
+     * @return {!IronRequestElement}
      */
     generateRequest: function() {
-      var request = document.createElement('iron-request');
+      var request = /** @type {!IronRequestElement} */ (document.createElement('iron-request'));
       var requestOptions = this.toRequestOptions();
 
       this.activeRequests.push(request);
 
       request.completes.then(
         this._boundHandleResponse
       ).catch(
-        this.handleError.bind(this, request)
+        this._handleError.bind(this, request)
       ).then(
-        this._boundDiscardRequest
+        this._discardRequest.bind(this, request)
       );
 
       request.send(requestOptions);
 
       this._setLastRequest(request);
+      this._setLoading(true);
 
       this.fire('request', {
         request: request,
         options: requestOptions
       });
 
       return request;
     },
 
-    handleResponse: function(request) {
+    _handleResponse: function(request) {
       this._setLastResponse(request.response);
       this.fire('response', request);
     },
 
-    handleError: function(request, error) {
+    _handleError: function(request, error) {
       if (this.verbose) {
         console.error(error);
       }
 
       this._setLastError({
         request: request,
         error: error
       });
       this.fire('error', {
         request: request,
         error: error
       });
     },
 
-    discardRequest: function(request) {
+    _discardRequest: function(request) {
       var requestIndex = this.activeRequests.indexOf(request);
 
-      if (requestIndex > 0) {
+      if (requestIndex > -1) {
         this.activeRequests.splice(requestIndex, 1);
       }
-    }
+
+      if (this.activeRequests.length === 0) {
+        this._setLoading(false);
+      }
+    },
+
+    _requestOptionsChanged: function() {
+      this.debounce('generate-request', function() {
+        if (!this.url && this.url !== '') {
+          return;
+        }
+
+        if (this.auto) {
+          this.generateRequest();
+        }
+      }, this.debounceDuration);
+    },
+
   });
 </script>