[MD settings] updating polymer to 1.1.13

third_party/polymer/v1_0/components-chromium/paper-input/paper-input-container-extracted.js

-(function() {
-
-  Polymer({
-
+Polymer({
     is: 'paper-input-container',
 
     properties: {
-
       /**
        * Set to true to disable the floating label. The label disappears when the input value is
        * not null.
        */
       noLabelFloat: {
         type: Boolean,
         value: false
       },
 
       /**
@@ skipping 29 matching lines @@
         type: Boolean,
         value: false
       },
 
       /**
        * True if the input has focus.
        */
       focused: {
         readOnly: true,
         type: Boolean,
-        value: false
+        value: false,
+        notify: true
       },
 
       _addons: {
         type: Array
         // do not set a default value here intentionally - it will be initialized lazily when a
         // distributed child is attached, which may occur before configuration for this element
         // in polyfill.
       },
 
       _inputHasContent: {
@@ skipping 26 matching lines @@
           return this._onInput.bind(this);
         }
       },
 
       _boundValueChanged: {
         type: Function,
         value: function() {
           return this._onValueChanged.bind(this);
         }
       }
-
     },
 
     listeners: {
       'addon-attached': '_onAddonAttached',
       'iron-input-validate': '_onIronInputValidate'
     },
 
     get _valueChangedEvent() {
       return this.attrForValue + '-changed';
     },
 
     get _propertyForValue() {
       return Polymer.CaseMap.dashToCamelCase(this.attrForValue);
     },
 
     get _inputElement() {
       return Polymer.dom(this).querySelector(this._inputSelector);
     },
 
+    get _inputElementValue() {
+      return this._inputElement[this._propertyForValue] || this._inputElement.value;
+    },
+
     ready: function() {
       if (!this._addons) {
         this._addons = [];
       }
       this.addEventListener('focus', this._boundOnFocus, true);
       this.addEventListener('blur', this._boundOnBlur, true);
       if (this.attrForValue) {
         this._inputElement.addEventListener(this._valueChangedEvent, this._boundValueChanged);
       } else {
         this.addEventListener('input', this._onInput);
       }
     },
 
     attached: function() {
-      this._handleValue(this._inputElement);
+      // Only validate when attached if the input already has a value.
+      if (this._inputElementValue != '') {
+        this._handleValueAndAutoValidate(this._inputElement);
+      } else {
+        this._handleValue(this._inputElement);
+      }
     },
 
     _onAddonAttached: function(event) {
       if (!this._addons) {
         this._addons = [];
       }
       var target = event.target;
       if (this._addons.indexOf(target) === -1) {
         this._addons.push(target);
         if (this.isAttached) {
           this._handleValue(this._inputElement);
         }
       }
     },
 
     _onFocus: function() {
       this._setFocused(true);
     },
 
     _onBlur: function() {
       this._setFocused(false);
+      this._handleValueAndAutoValidate(this._inputElement);
     },
 
     _onInput: function(event) {
-      this._handleValue(event.target);
+      this._handleValueAndAutoValidate(event.target);
     },
 
     _onValueChanged: function(event) {
-      this._handleValue(event.target);
+      this._handleValueAndAutoValidate(event.target);
     },
 
     _handleValue: function(inputElement) {
-      var value = inputElement[this._propertyForValue] || inputElement.value;
-
-      if (this.autoValidate) {
-        var valid;
-        if (inputElement.validate) {
-          valid = inputElement.validate(value);
-        } else {
-          valid = inputElement.checkValidity();
-        }
-        this.invalid = !valid;
-      }
+      var value = this._inputElementValue;
 
       // type="number" hack needed because this.value is empty until it's valid
       if (value || value === 0 || (inputElement.type === 'number' && !inputElement.checkValidity())) {
         this._inputHasContent = true;
       } else {
         this._inputHasContent = false;
       }
 
       this.updateAddons({
         inputElement: inputElement,
         value: value,
         invalid: this.invalid
       });
     },
 
+    _handleValueAndAutoValidate: function(inputElement) {
+      if (this.autoValidate) {
+        var valid;
+        if (inputElement.validate) {
+          valid = inputElement.validate(this._inputElementValue);
+        } else {
+          valid = inputElement.checkValidity();
+        }
+        this.invalid = !valid;
+      }
+
+      // Call this last to notify the add-ons.
+      this._handleValue(inputElement);
+    },
+
     _onIronInputValidate: function(event) {
       this.invalid = this._inputElement.invalid;
     },
 
     _invalidChanged: function() {
       if (this._addons) {
         this.updateAddons({invalid: this.invalid});
       }
     },
 
@@ skipping 51 matching lines @@
 
     _computeAddOnContentClass: function(focused, invalid) {
       var cls = 'add-on-content';
       if (invalid) {
         cls += ' is-invalid';
       } else if (focused) {
         cls += ' is-highlighted'
       }
       return cls;
     }
-
-  });
-
-})();
+  });