Revert of [Polymer] update polymer

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

 (function() {
     var Utility = {
       distance: function(x1, y1, x2, y2) {
         var xDelta = (x1 - x2);
         var yDelta = (y1 - y2);
 
         return Math.sqrt(xDelta * xDelta + yDelta * yDelta);
       },
 
       now: window.performance && window.performance.now ?
@@ skipping 382 matching lines @@
 
         _boundAnimate: {
           type: Function,
           value: function() {
             return this.animate.bind(this);
           }
         }
       },
 
       get target () {
-        return this.keyEventTarget;
+        var ownerRoot = Polymer.dom(this).getOwnerRoot();
+        var target;
+
+        if (this.parentNode.nodeType == 11) { // DOCUMENT_FRAGMENT_NODE
+          target = ownerRoot.host;
+        } else {
+          target = this.parentNode;
+        }
+
+        return target;
       },
 
       keyBindings: {
         'enter:keydown': '_onEnterKeydown',
         'space:keydown': '_onSpaceKeydown',
         'space:keyup': '_onSpaceKeyup'
       },
 
       attached: function() {
         // Set up a11yKeysBehavior to listen to key events on the target,
         // so that space and enter activate the ripple even if the target doesn't
         // handle key events. The key handlers deal with `noink` themselves.
-        if (this.parentNode.nodeType == 11) { // DOCUMENT_FRAGMENT_NODE
-          this.keyEventTarget = Polymer.dom(this).getOwnerRoot().host;
-        } else {
-          this.keyEventTarget = this.parentNode;
-        }
-        var keyEventTarget = /** @type {!EventTarget} */ (this.keyEventTarget);
-        this.listen(keyEventTarget, 'up', 'uiUpAction');
-        this.listen(keyEventTarget, 'down', 'uiDownAction');
+        this.keyEventTarget = this.target;
+        this.listen(this.target, 'up', 'uiUpAction');
+        this.listen(this.target, 'down', 'uiDownAction');
       },
 
       detached: function() {
-        this.unlisten(this.keyEventTarget, 'up', 'uiUpAction');
-        this.unlisten(this.keyEventTarget, 'down', 'uiDownAction');
-        this.keyEventTarget = null;
+        this.unlisten(this.target, 'up', 'uiUpAction');
+        this.unlisten(this.target, 'down', 'uiDownAction');
       },
 
       get shouldKeepAnimating () {
         for (var index = 0; index < this.ripples.length; ++index) {
           if (!this.ripples[index].isAnimationComplete) {
             return true;
           }
         }
 
         return false;
@@ skipping 27 matching lines @@
       downAction: function(event) {
         if (this.holdDown && this.ripples.length > 0) {
           return;
         }
 
         var ripple = this.addRipple();
 
         ripple.downAction(event);
 
         if (!this._animating) {
-          this._animating = true;
           this.animate();
         }
       },
 
       /**
        * Provokes a ripple up effect via a UI event,
        * respecting the `noink` property.
        * @param {Event=} event
        */
       uiUpAction: function(event) {
         if (!this.noink) {
           this.upAction(event);
         }
       },
 
       /**
        * Provokes a ripple up effect via a UI event,
        * *not* respecting the `noink` property.
        * @param {Event=} event
        */
       upAction: function(event) {
         if (this.holdDown) {
           return;
         }
 
         this.ripples.forEach(function(ripple) {
           ripple.upAction(event);
         });
 
-        this._animating = true;
         this.animate();
       },
 
       onAnimationComplete: function() {
         this._animating = false;
         this.$.background.style.backgroundColor = null;
         this.fire('transitionend');
       },
 
       addRipple: function() {
@@ skipping 18 matching lines @@
         this.ripples.splice(rippleIndex, 1);
 
         ripple.remove();
 
         if (!this.ripples.length) {
           this._setAnimating(false);
         }
       },
 
       animate: function() {
-        if (!this._animating) {
-          return;
-        }
         var index;
         var ripple;
 
+        this._animating = true;
+
         for (index = 0; index < this.ripples.length; ++index) {
           ripple = this.ripples[index];
 
           ripple.draw();
 
           this.$.background.style.opacity = ripple.outerOpacity;
 
           if (ripple.isOpacityFullyDecayed && !ripple.isRestingAtMaxRadius) {
             this.removeRipple(ripple);
           }
@@ skipping 24 matching lines @@
       _holdDownChanged: function(newVal, oldVal) {
         if (oldVal === undefined) {
           return;
         }
         if (newVal) {
           this.downAction();
         } else {
           this.upAction();
         }
       }
-
-      /**
-      Fired when the animation finishes.
-      This is useful if you want to wait until
-      the ripple animation finishes to perform some action.
-
-      @event transitionend
-      @param {{node: Object}} detail Contains the animated node.
-      */
     });
   })();