Update Polymer components and re-run reproduce.sh

third_party/polymer/v1_0/components-chromium/paper-drawer-panel/paper-drawer-panel-extracted.js

 
 
   (function() {
 
     'use strict';
 
    // this would be the only `paper-drawer-panel` in
    // the whole app that can be in `dragging` state
     var sharedPanel = null;
 
@@ skipping 56 matching lines @@
         disableSwipe: {
           type: Boolean,
           value: false
         },
 
         /**
          * Whether the user is dragging the drawer interactively.
          */
         dragging: {
           type: Boolean,
-          value: false
+          value: false,
+          readOnly: true,
+          notify: true
         },
 
         /**
          * Width of the drawer panel.
          */
         drawerWidth: {
           type: String,
           value: '256px'
         },
 
@@ skipping 35 matching lines @@
         },
 
         /**
          * Returns true if the panel is in narrow layout.  This is useful if you
          * need to show/hide elements based on the layout.
          */
         narrow: {
           reflectToAttribute: true,
           type: Boolean,
           value: false,
+          readOnly: true,
           notify: true
         },
 
         /**
          * Whether the drawer is peeking out from the edge.
          */
         peeking: {
           type: Boolean,
-          value: false
+          value: false,
+          readOnly: true,
+          notify: true
         },
 
         /**
          * Max-width when the panel changes to narrow layout.
          */
         responsiveWidth: {
           type: String,
           value: '640px'
         },
 
         /**
          * If true, position the drawer to the right.
          */
         rightDrawer: {
           type: Boolean,
           value: false
         },
 
         /**
          * The panel that is being selected. `drawer` for the drawer panel and
          * `main` for the main panel.
          */
         selected: {
           reflectToAttribute: true,
+          notify: true,
           type: String,
           value: null
         },
 
         /**
          * The attribute on elements that should toggle the drawer on tap, also elements will
          * automatically be hidden in wide layout.
          */
         drawerToggleAttribute: {
           type: String,
@@ skipping 106 matching lines @@
             this._trackX(e);
             break;
           case 'end':
             this._trackEnd(e);
             break;
         }
 
       },
 
       _responsiveChange: function(narrow) {
-        this.narrow = narrow;
+        this._setNarrow(narrow);
 
         if (this.narrow) {
           this.selected = this.defaultSelected;
         }
 
         this.setScrollDirection(this._swipeAllowed() ? 'y' : 'all');
         this.fire('paper-responsive-change', {narrow: this.narrow});
       },
 
       _onQueryMatchesChanged: function(e) {
@@ skipping 10 matching lines @@
       },
 
       _isMainSelected: function() {
         return this.selected === 'main';
       },
 
       _startEdgePeek: function() {
         this.width = this.$.drawer.offsetWidth;
         this._moveDrawer(this._translateXForDeltaX(this.rightDrawer ?
             -this.edgeSwipeSensitivity : this.edgeSwipeSensitivity));
-        this.peeking = true;
+        this._setPeeking(true);
       },
 
       _stopEdgePeek: function() {
         if (this.peeking) {
-          this.peeking = false;
+          this._setPeeking(false);
           this._moveDrawer(null);
         }
       },
 
       _downHandler: function(e) {
         if (!this.dragging && this._isMainSelected() && this._isEdgeTouch(e) && !sharedPanel) {
           this._startEdgePeek();
           // grab this panel
           sharedPanel = this;
         }
@@ skipping 18 matching lines @@
 
       _isEdgeTouch: function(e) {
         var x = e.detail.x;
 
         return !this.disableEdgeSwipe && this._swipeAllowed() &&
           (this.rightDrawer ?
             x >= this.offsetWidth - this.edgeSwipeSensitivity :
             x <= this.edgeSwipeSensitivity);
       },
 
-      _trackStart: function() {
+      _trackStart: function(event) {
         if (this._swipeAllowed()) {
           sharedPanel = this;
-          this.dragging = true;
+          this._setDragging(true);
 
           if (this._isMainSelected()) {
-            this.dragging = this.peeking || this._isEdgeTouch(event);
+            this._setDragging(this.peeking || this._isEdgeTouch(event));
           }
 
           if (this.dragging) {
             this.width = this.$.drawer.offsetWidth;
             this.transition = false;
           }
         }
       },
 
       _translateXForDeltaX: function(deltaX) {
         var isMain = this._isMainSelected();
 
         if (this.rightDrawer) {
           return Math.max(0, isMain ? this.width + deltaX : deltaX);
         } else {
           return Math.min(0, isMain ? deltaX - this.width : deltaX);
         }
       },
 
       _trackX: function(e) {
         if (this.dragging) {
           var dx = e.detail.dx;
 
           if (this.peeking) {
             if (Math.abs(dx) <= this.edgeSwipeSensitivity) {
               // Ignore trackx until we move past the edge peek.
               return;
             }
-            this.peeking = false;
+            this._setPeeking(false);
           }
 
           this._moveDrawer(this._translateXForDeltaX(dx));
         }
       },
 
       _trackEnd: function(e) {
         if (this.dragging) {
           var xDirection = e.detail.dx > 0;
 
-          this.dragging = false;
+          this._setDragging(false);
           this.transition = true;
           sharedPanel = null;
           this._moveDrawer(null);
 
           if (this.rightDrawer) {
             this[xDirection ? 'closeDrawer' : 'openDrawer']();
           } else {
             this[xDirection ? 'openDrawer' : 'closeDrawer']();
           }
         }
@@ skipping 15 matching lines @@
           s.transform = this._transformForTranslateX(translateX);
         } else {
           s.webkitTransform = this._transformForTranslateX(translateX);
         }
       }
 
     });
 
   }());