Update Polymer from 1.1.4 -> 1.1.5

third_party/polymer/v1_0/components-chromium/paper-tooltip/paper-tooltip-extracted.js

-
-    Polymer({
+Polymer({
       is: 'paper-tooltip',
 
       hostAttributes: {
         role: 'tooltip',
         tabindex: -1
       },
 
       behaviors: [
         Polymer.NeonAnimationRunnerBehavior
       ],
@@ skipping 37 matching lines @@
          * This property is deprecated, but left over so that it doesn't
          * break exiting code. Please use `offset` instead. If both `offset` and
          * `marginTop` are provided, `marginTop` will be ignored.
          * @deprecated since version 1.0.3
          */
         marginTop: {
           type: Number,
           value: 14
         },
 
+        /**
+         * The delay that will be applied before the `entry` animation is
+         * played when showing the tooltip.
+         */
+        animationDelay: {
+          type: Number,
+          value: 500
+        },
+
+        /**
+         * The entry and exit animations that will be played when showing and
+         * hiding the tooltip. If you want to override this, you must ensure
+         * that your animationConfig has the exact format below.
+         */
         animationConfig: {
           type: Object,
           value: function() {
             return {
               'entry': [{
                 name: 'fade-in-animation',
                 node: this,
-                timing: {delay: 500}
+                timing: {delay: 0}
               }],
               'exit': [{
                 name: 'fade-out-animation',
                 node: this
               }]
             }
           }
         },
 
         _showing: {
           type: Boolean,
           value: false
         }
       },
 
       listeners: {
-        'neon-animation-finish': '_onAnimationFinish'
+        'neon-animation-finish': '_onAnimationFinish',
+        'mouseenter': 'hide'
       },
 
       /**
        * Returns the target element that this tooltip is anchored to. It is
        * either the element given by the `for` attribute, or the immediate parent
        * of the tooltip.
        */
       get target () {
         var parentNode = Polymer.dom(this).parentNode;
         // If the parentNode is a document fragment, then we need to use the host.
@@ skipping 10 matching lines @@
         return target;
       },
 
       attached: function() {
         this._target = this.target;
 
         this.listen(this._target, 'mouseenter', 'show');
         this.listen(this._target, 'focus', 'show');
         this.listen(this._target, 'mouseleave', 'hide');
         this.listen(this._target, 'blur', 'hide');
+        this.listen(this._target, 'tap', 'hide');
       },
 
       detached: function() {
         if (this._target) {
           this.unlisten(this._target, 'mouseenter', 'show');
           this.unlisten(this._target, 'focus', 'show');
           this.unlisten(this._target, 'mouseleave', 'hide');
           this.unlisten(this._target, 'blur', 'hide');
+          this.unlisten(this._target, 'tap', 'hide');
         }
       },
 
       show: function() {
+        // If the tooltip is already showing, there's nothing to do.
         if (this._showing)
           return;
 
         if (Polymer.dom(this).textContent.trim() === '')
           return;
 
+
         this.cancelAnimation();
-
+        this._showing = true;
         this.toggleClass('hidden', false, this.$.tooltip);
         this.updatePosition();
-        this._showing = true;
 
+        this.animationConfig.entry[0].timing.delay = this.animationDelay;
+        this._animationPlaying = true;
         this.playAnimation('entry');
       },
 
       hide: function() {
-        if (!this._showing)
+        // If the tooltip is already hidden, there's nothing to do.
+        if (!this._showing) {
           return;
+        }
+
+        // If the entry animation is still playing, don't try to play the exit
+        // animation since this will reset the opacity to 1. Just end the animation.
+        if (this._animationPlaying) {
+          this.cancelAnimation();
+          this._showing = false;
+          this._onAnimationFinish();
+          return;
+        }
 
         this._showing = false;
+        this._animationPlaying = true;
         this.playAnimation('exit');
       },
 
       _forChanged: function() {
         this._target = this.target;
       },
 
       updatePosition: function() {
         if (!this._target)
           return;
@@ skipping 54 matching lines @@
             this.style.bottom = 'auto';
           }
         } else {
           this.style.left = tooltipLeft + 'px';
           this.style.top = tooltipTop + 'px';
         }
 
       },
 
       _onAnimationFinish: function() {
+        this._animationPlaying = false;
         if (!this._showing) {
           this.toggleClass('hidden', true, this.$.tooltip);
         }
       },
-    });
-  
+    });