[Polymer] update paper-slider for RTL support

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

 Polymer({
       is: 'paper-slider',
 
       behaviors: [
         Polymer.IronA11yKeysBehavior,
         Polymer.IronFormElementBehavior,
         Polymer.PaperInkyFocusBehavior,
         Polymer.IronRangeBehavior
       ],
 
@@ skipping 96 matching lines @@
         '_immediateValueChanged(immediateValue)',
         '_updateMarkers(maxMarkers, min, max, snaps)'
       ],
 
       hostAttributes: {
         role: 'slider',
         tabindex: 0
       },
 
       keyBindings: {
-        'left down pagedown home': '_decrementKey',
-        'right up pageup end': '_incrementKey'
+        'left': '_leftKey',
+        'right': '_rightKey',
+        'down pagedown home': '_decrementKey',
+        'up pageup end': '_incrementKey'
       },
 
       /**
        * Increases value by `step` but not above `max`.
        * @method increment
        */
       increment: function() {
         this.value = this._clampValue(this.value + this.step);
       },
 
@@ skipping 77 matching lines @@
         this._maxx = this._w - this._startx;
         this.$.sliderKnob.classList.add('dragging');
         this._setDragging(true);
       },
 
       _trackX: function(event) {
         if (!this.dragging) {
           this._trackStart(event);
         }
 
-        var dx = Math.min(this._maxx, Math.max(this._minx, event.detail.dx));
+        var direction = this._isRTL ? -1 : 1;
+        var dx = Math.min(
+            this._maxx, Math.max(this._minx, event.detail.dx * direction));
         this._x = this._startx + dx;
 
         var immediateValue = this._calcStep(this._calcKnobPosition(this._x / this._w));
         this._setImmediateValue(immediateValue);
 
         // update knob's position
         var translateX = ((this._calcRatio(this.immediateValue) * this._w) - this._knobstartx);
         this.translate3d(translateX + 'px', 0, 0, this.$.sliderKnob);
       },
 
@@ skipping 17 matching lines @@
         event.preventDefault();
 
         // set the focus manually because we will called prevent default
         this.focus();
       },
 
       _bardown: function(event) {
         this._w = this.$.sliderBar.offsetWidth;
         var rect = this.$.sliderBar.getBoundingClientRect();
         var ratio = (event.detail.x - rect.left) / this._w;
+        if (this._isRTL) {
+          ratio = 1 - ratio;
+        }
         var prevRatio = this.ratio;
 
         this._setTransiting(true);
 
         this._positionKnob(ratio);
 
         this.debounce('expandKnob', this._expandKnob, 60);
 
         // if the ratio doesn't change, sliderKnob's animation won't start
         // and `_knobTransitionEnd` won't be called
@@ skipping 21 matching lines @@
       },
 
       _updateMarkers: function(maxMarkers, min, max, snaps) {
         if (!snaps) {
           this._setMarkers([]);
         }
         var steps = Math.round((max - min) / this.step);
         if (steps > maxMarkers) {
           steps = maxMarkers;
         }
+        if (steps < 0 || !isFinite(steps)) {
+          steps = 0;
+        }

[dschuyler, 2017/04/07 02:59:59]

This is a change that wasn't in my PR, but it looks like a fine change to me.

         this._setMarkers(new Array(steps));
       },
 
       _mergeClasses: function(classes) {
         return Object.keys(classes).filter(
           function(className) {
             return classes[className];
           }).join(' ');
       },
 
       _getClassNames: function() {
         return this._mergeClasses({
           disabled: this.disabled,
           pin: this.pin,
           snaps: this.snaps,
           ring: this.immediateValue <= this.min,
           expand: this.expand,
           dragging: this.dragging,
           transiting: this.transiting,
           editable: this.editable
         });
       },
 
+      get _isRTL() {
+        if (this.__isRTL === undefined) {
+          this.__isRTL = window.getComputedStyle(this)['direction'] === 'rtl';
+        }
+        return this.__isRTL;
+      },
+
+      _leftKey: function(event) {
+        if (this._isRTL)
+          this._incrementKey(event);
+        else
+          this._decrementKey(event);
+      },
+
+      _rightKey: function(event) {
+        if (this._isRTL)
+          this._decrementKey(event);
+        else
+          this._incrementKey(event);
+      },
+
       _incrementKey: function(event) {
         if (!this.disabled) {
           if (event.detail.key === 'end') {
             this.value = this.max;
           } else {
             this.increment();
           }
           this.fire('change');
           event.preventDefault();
         }
@@ skipping 63 matching lines @@
      */
 
     /**
      * Fired when the slider's value changes due to user interaction.
      *
      * Changes to the slider's value due to changes in an underlying
      * bound variable will not trigger this event.
      *
      * @event change
      */