[Polymer] Roll polymer to latest version

third_party/polymer/v1_0/components-chromium/iron-input/iron-input-extracted.js

 /*
 `<iron-input>` adds two-way binding and custom validators using `Polymer.IronValidatorBehavior`
 to `<input>`.
 
 ### Two-way binding
 
 By default you can only get notified of changes to an `input`'s `value` due to user input:
 
     <input value="{{myValue::input}}">
 
@@ skipping 36 matching lines @@
       /**
        * Use this property instead of `value` for two-way data binding.
        */
       bindValue: {
         observer: '_bindValueChanged',
         type: String
       },
 
       /**
        * Set to true to prevent the user from entering invalid input. The new input characters are
-       * matched with `allowedPattern` if it is set, otherwise it will use the `pattern` attribute if
-       * set, or the `type` attribute (only supported for `type=number`).
+       * matched with `allowedPattern` if it is set, otherwise it will use the `type` attribute (only
+       * supported for `type=number`).
        */
       preventInvalidInput: {
         type: Boolean
       },
 
       /**
-       * Regular expression to match valid input characters.
+       * Regular expression expressing a set of characters to enforce the validity of input characters.
+       * The recommended value should follow this format: `[a-ZA-Z0-9.+-!;:]` that list the characters 
+       * allowed as input.
        */
       allowedPattern: {
         type: String,
         observer: "_allowedPatternChanged"
       },
 
       _previousValidInput: {
         type: String,
         value: ''
       },
 
       _patternAlreadyChecked: {
         type: Boolean,
         value: false
       }
 
     },
 
     listeners: {
       'input': '_onInput',
       'keypress': '_onKeypress'
     },
 
     get _patternRegExp() {
       var pattern;
       if (this.allowedPattern) {
         pattern = new RegExp(this.allowedPattern);
-      } else if (this.pattern) {
-        pattern = new RegExp(this.pattern);
       } else {
         switch (this.type) {
           case 'number':
             pattern = /[0-9.,e-]/;
             break;
         }
       }
       return pattern;
     },
 
     ready: function() {
       this.bindValue = this.value;
     },
 
     /**
      * @suppress {checkTypes}
      */
     _bindValueChanged: function() {
       if (this.value !== this.bindValue) {
-        this.value = !(this.bindValue || this.bindValue === 0) ? '' : this.bindValue;
+        this.value = !(this.bindValue || this.bindValue === 0 || this.bindValue === false) ? '' : this.bindValue;
       }
       // manually notify because we don't want to notify until after setting value
       this.fire('bind-value-changed', {value: this.bindValue});
     },
 
     _allowedPatternChanged: function() {
       // Force to prevent invalid input when an `allowed-pattern` is set
       this.preventInvalidInput = this.allowedPattern ? true : false;
     },
 
@@ skipping 88 matching lines @@
       // Empty, non-required input is valid.
       if (!this.required && this.value == '') {
         this.invalid = false;
         return true;
       }
 
       var valid;
       if (this.hasValidator()) {
         valid = Polymer.IronValidatableBehavior.validate.call(this, this.value);
       } else {
-        this.invalid = !this.validity.valid;
-        valid = this.validity.valid;
+        valid = this.checkValidity();
+        this.invalid = !valid;
       }
       this.fire('iron-input-validate');
       return valid;
     }
 
   });
 
   /*
   The `iron-input-validate` event is fired whenever `validate()` is called.
   @event iron-input-validate
   */