From 18ba9ae0d904ac5dc8c8c2e1b747a9f72d896655 Mon Sep 17 00:00:00 2001
From: Steven Orvell <sorvell@google.com>
Date: Thu, 14 Feb 2019 16:38:56 -0800
Subject: [PATCH 01/29] Add `classList` to `Polymer.dom` when
 `ShadyDOM.noPatch` is used

Fixes #5488
---
 lib/legacy/polymer.dom.js          |   4 +
 test/unit/polymer-dom-nopatch.html | 138 +++++++++++++++++++++++++++++
 test/unit/polymer-dom.html         | 138 +++++++++++++++++++++++++++++
 3 files changed, 280 insertions(+)

diff --git a/lib/legacy/polymer.dom.js b/lib/legacy/polymer.dom.js
index 442d428147..cf5c1ddc66 100644
--- a/lib/legacy/polymer.dom.js
+++ b/lib/legacy/polymer.dom.js
@@ -395,6 +395,10 @@ if (window['ShadyDOM'] && window['ShadyDOM']['inUse'] && window['ShadyDOM']['noP
     }
   });
 
+  forwardReadOnlyProperties(Wrapper.prototype, [
+    'classList'
+  ]);
+
   DomApiImpl = Wrapper;
 
   Object.defineProperties(EventApi.prototype, {
diff --git a/test/unit/polymer-dom-nopatch.html b/test/unit/polymer-dom-nopatch.html
index 54017de804..6a7e697110 100644
--- a/test/unit/polymer-dom-nopatch.html
+++ b/test/unit/polymer-dom-nopatch.html
@@ -355,6 +355,144 @@
     assert.equal(useNativeCSSProperties, Boolean(!window.ShadyCSS || window.ShadyCSS.nativeCss));
   });
 
+});
+
+suite('forwarded native api', function() {
+
+  let el;
+
+  setup(function() {
+    el = document.createElement('x-container-slot');
+    document.body.appendChild(el);
+  });
+
+  teardown(function() {
+    document.body.removeChild(el);
+  });
+
+  test('accessors are available', function() {
+    const d = dom(el);
+    assert.isDefined(d.parentNode);
+    assert.isDefined(d.firstChild);
+    assert.isDefined(d.lastChild);
+    assert.isDefined(d.nextSibling);
+    assert.isDefined(d.previousSibling);
+    assert.isDefined(d.firstElementChild);
+    assert.isDefined(d.lastElementChild);
+    assert.isDefined(d.nextElementSibling);
+    assert.isDefined(d.previousElementSibling);
+    assert.isDefined(d.childNodes);
+    assert.isDefined(d.children);
+    assert.isDefined(d.classList);
+    assert.isDefined(d.textContent);
+    assert.isDefined(d.innerHTML);
+  });
+
+  test('cloneNode', function() {
+    const clone = dom(el).cloneNode(el);
+    assert.ok(clone);
+    assert.equal(clone.localName, 'x-container-slot');
+  });
+
+  test('appendChild', function() {
+    const d1 = document.createElement('div');
+    dom(el).appendChild(d1);
+    assert.equal(dom(el).firstChild, d1);
+    assert.equal(dom(d1).parentNode, el);
+  });
+
+  test('insertBefore', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).insertBefore(d2, d1);
+    assert.equal(dom(d2).nextSibling, d1);
+  });
+
+  test('removeChild', function() {
+    const d1 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).removeChild(d1);
+    assert.equal(dom(d1).parentNode, null);
+  });
+
+  test('replaceChild', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).replaceChild(d2, d1);
+    assert.equal(dom(d1).parentNode, null);
+    assert.equal(dom(el).firstChild, d2);
+    assert.equal(dom(d2).parentNode, el);
+  });
+
+  test('replaceChild', function() {
+    dom(el).setAttribute('foo', 'foo');
+    assert.equal(el.getAttribute('foo'), 'foo');
+  });
+
+  test('replaceChild', function() {
+    dom(el).setAttribute('foo', 'foo');
+    dom(el).removeAttribute('foo');
+    assert.isFalse(el.hasAttribute('foo'));
+  });
+
+  test('querySelector', function() {
+    const d1 = document.createElement('div');
+    dom(el).appendChild(d1);
+    const query = dom(el).querySelector('div');
+    assert.equal(query, d1);
+  });
+
+  test('querySelectorAll', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).appendChild(d2);
+    const query = dom(el).querySelectorAll('div');
+    assert.equal(query[0], d1);
+    assert.equal(query[1], d2);
+    assert.equal(query.length, 2);
+  });
+
+  test('tree accessors', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).appendChild(d2);
+    const pel = dom(el);
+    const pd1 = dom(d1);
+    const pd2 = dom(d2);
+    assert.equal(pd1.parentNode, el);
+    assert.equal(pel.firstChild, d1);
+    assert.equal(pel.lastChild, d2);
+    assert.equal(pel.firstElementChild, d1);
+    assert.equal(pel.lastElementChild, d2);
+    assert.equal(pd1.nextSibling, d2);
+    assert.equal(pd2.previousSibling, d1);
+    assert.equal(pd1.nextElementSibling, d2);
+    assert.equal(pd2.previousElementSibling, d1);
+    assert.equal(pel.childNodes[0], d1);
+    assert.equal(pel.childNodes[1], d2);
+    assert.equal(pel.children[0], d1);
+    assert.equal(pel.children[1], d2);
+  });
+
+  test('innerHTML', function() {
+    dom(el).innerHTML = '<div></div>';
+    assert.equal(dom(el).firstChild.localName, 'div');
+  });
+
+  test('textContent', function() {
+    dom(el).innerHTML = 'hi';
+    assert.equal(dom(dom(el).firstChild).textContent, 'hi');
+  });
+
+  test('classList', function() {
+    dom(el).classList.add('foo');
+    assert.equal(el.className, 'foo');
+  });
+
 });
 </script>
 
diff --git a/test/unit/polymer-dom.html b/test/unit/polymer-dom.html
index 8bea7e1c1f..30cc025654 100644
--- a/test/unit/polymer-dom.html
+++ b/test/unit/polymer-dom.html
@@ -342,6 +342,144 @@
     assert.equal(useNativeCSSProperties, Boolean(!window.ShadyCSS || window.ShadyCSS.nativeCss));
   });
 
+});
+
+suite('forwarded native api', function() {
+
+  let el;
+
+  setup(function() {
+    el = document.createElement('x-container-slot');
+    document.body.appendChild(el);
+  });
+
+  teardown(function() {
+    document.body.removeChild(el);
+  });
+
+  test('accessors are available', function() {
+    const d = dom(el);
+    assert.isDefined(d.parentNode);
+    assert.isDefined(d.firstChild);
+    assert.isDefined(d.lastChild);
+    assert.isDefined(d.nextSibling);
+    assert.isDefined(d.previousSibling);
+    assert.isDefined(d.firstElementChild);
+    assert.isDefined(d.lastElementChild);
+    assert.isDefined(d.nextElementSibling);
+    assert.isDefined(d.previousElementSibling);
+    assert.isDefined(d.childNodes);
+    assert.isDefined(d.children);
+    assert.isDefined(d.classList);
+    assert.isDefined(d.textContent);
+    assert.isDefined(d.innerHTML);
+  });
+
+  test('cloneNode', function() {
+    const clone = dom(el).cloneNode(el);
+    assert.ok(clone);
+    assert.equal(clone.localName, 'x-container-slot');
+  });
+
+  test('appendChild', function() {
+    const d1 = document.createElement('div');
+    dom(el).appendChild(d1);
+    assert.equal(dom(el).firstChild, d1);
+    assert.equal(dom(d1).parentNode, el);
+  });
+
+  test('insertBefore', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).insertBefore(d2, d1);
+    assert.equal(dom(d2).nextSibling, d1);
+  });
+
+  test('removeChild', function() {
+    const d1 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).removeChild(d1);
+    assert.equal(dom(d1).parentNode, null);
+  });
+
+  test('replaceChild', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).replaceChild(d2, d1);
+    assert.equal(dom(d1).parentNode, null);
+    assert.equal(dom(el).firstChild, d2);
+    assert.equal(dom(d2).parentNode, el);
+  });
+
+  test('replaceChild', function() {
+    dom(el).setAttribute('foo', 'foo');
+    assert.equal(el.getAttribute('foo'), 'foo');
+  });
+
+  test('replaceChild', function() {
+    dom(el).setAttribute('foo', 'foo');
+    dom(el).removeAttribute('foo');
+    assert.isFalse(el.hasAttribute('foo'));
+  });
+
+  test('querySelector', function() {
+    const d1 = document.createElement('div');
+    dom(el).appendChild(d1);
+    const query = dom(el).querySelector('div');
+    assert.equal(query, d1);
+  });
+
+  test('querySelectorAll', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).appendChild(d2);
+    const query = dom(el).querySelectorAll('div');
+    assert.equal(query[0], d1);
+    assert.equal(query[1], d2);
+    assert.equal(query.length, 2);
+  });
+
+  test('tree accessors', function() {
+    const d1 = document.createElement('div');
+    const d2 = document.createElement('div');
+    dom(el).appendChild(d1);
+    dom(el).appendChild(d2);
+    const pel = dom(el);
+    const pd1 = dom(d1);
+    const pd2 = dom(d2);
+    assert.equal(pd1.parentNode, el);
+    assert.equal(pel.firstChild, d1);
+    assert.equal(pel.lastChild, d2);
+    assert.equal(pel.firstElementChild, d1);
+    assert.equal(pel.lastElementChild, d2);
+    assert.equal(pd1.nextSibling, d2);
+    assert.equal(pd2.previousSibling, d1);
+    assert.equal(pd1.nextElementSibling, d2);
+    assert.equal(pd2.previousElementSibling, d1);
+    assert.equal(pel.childNodes[0], d1);
+    assert.equal(pel.childNodes[1], d2);
+    assert.equal(pel.children[0], d1);
+    assert.equal(pel.children[1], d2);
+  });
+
+  test('innerHTML', function() {
+    dom(el).innerHTML = '<div></div>';
+    assert.equal(dom(el).firstChild.localName, 'div');
+  });
+
+  test('textContent', function() {
+    dom(el).innerHTML = 'hi';
+    assert.equal(dom(dom(el).firstChild).textContent, 'hi');
+  });
+
+  test('classList', function() {
+    dom(el).classList.add('foo');
+    assert.equal(el.className, 'foo');
+  });
+
 });
 </script>
 

From ad05f567fb392bad1e6b3e3ea1d8b328a26192b7 Mon Sep 17 00:00:00 2001
From: Chad Killingsworth <chadkillingsworth@gmail.com>
Date: Wed, 20 Feb 2019 06:14:45 -0600
Subject: [PATCH 02/29] Add property reflection to notify path and friends
 calls to support closure-compiler renaming.

Also quotes the getStyle method of the custom style method since ShadyCSS references the method quoted.
---
 lib/elements/array-selector.js | 28 +++++++++++++++++-----------
 lib/elements/custom-style.js   |  2 +-
 lib/elements/dom-repeat.js     |  2 +-
 3 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/lib/elements/array-selector.js b/lib/elements/array-selector.js
index c4a9816749..158d242cea 100644
--- a/lib/elements/array-selector.js
+++ b/lib/elements/array-selector.js
@@ -107,7 +107,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
 
     __updateSelection(multi, itemsInfo) {
       let path = itemsInfo.path;
-      if (path == 'items') {
+      if (path == JSCompiler_renameProperty('items', this)) {
         // Case 1 - items array changed, so diff against previous array and
         // deselect any removed items and adjust selected indices
         let newItems = itemsInfo.base || [];
@@ -122,14 +122,14 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
         }
         this.__lastItems = newItems;
         this.__lastMulti = multi;
-      } else if (itemsInfo.path == 'items.splices') {
+      } else if (itemsInfo.path == `${JSCompiler_renameProperty('items', this)}.splices`) {
         // Case 2 - got specific splice information describing the array mutation:
         // deselect any removed items and adjust selected indices
         this.__applySplices(itemsInfo.value.indexSplices);
       } else {
         // Case 3 - an array element was changed, so deselect the previous
         // item for that index if it was previously selected
-        let part = path.slice('items.'.length);
+        let part = path.slice(`${JSCompiler_renameProperty('items', this)}.`.length);
         let idx = parseInt(part, 10);
         if ((part.indexOf('.') < 0) && part == idx) {
           this.__deselectChangedIdx(idx);
@@ -167,7 +167,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
       selected.forEach((idx, item) => {
         if (idx < 0) {
           if (this.multi) {
-            this.splice('selected', sidx, 1);
+            this.splice(JSCompiler_renameProperty('selected', this), sidx, 1);
           } else {
             this.selected = this.selectedItem = null;
           }
@@ -184,13 +184,19 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
         let sidx = 0;
         this.__selectedMap.forEach(idx => {
           if (idx >= 0) {
-            this.linkPaths('items.' + idx, 'selected.' + sidx++);
+            this.linkPaths(
+                `${JSCompiler_renameProperty('items', this)}.${idx}`,
+                `${JSCompiler_renameProperty('selected', this)}.${sidx++}`);
           }
         });
       } else {
         this.__selectedMap.forEach(idx => {
-          this.linkPaths('selected', 'items.' + idx);
-          this.linkPaths('selectedItem', 'items.' + idx);
+          this.linkPaths(
+              JSCompiler_renameProperty('selected', this),
+              `${JSCompiler_renameProperty('items', this)}.${idx}`);
+          this.linkPaths(
+              JSCompiler_renameProperty('selectedItem', this),
+              `${JSCompiler_renameProperty('items', this)}.${idx}`);
         });
       }
     }
@@ -248,9 +254,9 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
     }
 
     __selectedIndexForItemIndex(idx) {
-      let selected = this.__dataLinkedPaths['items.' + idx];
+      let selected = this.__dataLinkedPaths[`${JSCompiler_renameProperty('items', this)}.${idx}`];
       if (selected) {
-        return parseInt(selected.slice('selected.'.length), 10);
+        return parseInt(selected.slice(`${JSCompiler_renameProperty('selected', this)}.`.length), 10);
       }
     }
 
@@ -271,7 +277,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
         }
         this.__updateLinks();
         if (this.multi) {
-          this.splice('selected', sidx, 1);
+          this.splice(JSCompiler_renameProperty('selected', this), sidx, 1);
         } else {
           this.selected = this.selectedItem = null;
         }
@@ -318,7 +324,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
         this.__selectedMap.set(item, idx);
         this.__updateLinks();
         if (this.multi) {
-          this.push('selected', item);
+          this.push(JSCompiler_renameProperty('selected', this), item);
         } else {
           this.selected = this.selectedItem = item;
         }
diff --git a/lib/elements/custom-style.js b/lib/elements/custom-style.js
index f675393118..2bba4de8ab 100644
--- a/lib/elements/custom-style.js
+++ b/lib/elements/custom-style.js
@@ -75,7 +75,7 @@ export class CustomStyle extends HTMLElement {
    * @export
    * @return {HTMLStyleElement} This element's light-DOM `<style>`
    */
-  getStyle() {
+  'getStyle'() {
     if (this._style) {
       return this._style;
     }
diff --git a/lib/elements/dom-repeat.js b/lib/elements/dom-repeat.js
index e4ca665939..74f12659d9 100644
--- a/lib/elements/dom-repeat.js
+++ b/lib/elements/dom-repeat.js
@@ -382,7 +382,7 @@ export class DomRepeat extends domRepeatBase {
             if (prop == this.as) {
               this.items[idx] = value;
             }
-            let path = translate(this.as, 'items.' + idx, prop);
+            let path = translate(this.as, `${JSCompiler_renameProperty('items', this)}.${idx}`, prop);
             this.notifyPath(path, value);
           }
         }

From 764a233c2744ddb8e13ec9dd0fb89d539478cb23 Mon Sep 17 00:00:00 2001
From: Steven Orvell <sorvell@google.com>
Date: Wed, 20 Feb 2019 09:11:36 -0800
Subject: [PATCH 03/29] Added comment based on review feedback.

---
 lib/legacy/polymer.dom.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/lib/legacy/polymer.dom.js b/lib/legacy/polymer.dom.js
index cf5c1ddc66..6d7f0eb667 100644
--- a/lib/legacy/polymer.dom.js
+++ b/lib/legacy/polymer.dom.js
@@ -395,6 +395,8 @@ if (window['ShadyDOM'] && window['ShadyDOM']['inUse'] && window['ShadyDOM']['noP
     }
   });
 
+  // Note, `classList` is here only for legacy compatibility since it does not
+  // trigger distribution in v1 Shadow DOM.
   forwardReadOnlyProperties(Wrapper.prototype, [
     'classList'
   ]);
@@ -420,12 +422,17 @@ if (window['ShadyDOM'] && window['ShadyDOM']['inUse'] && window['ShadyDOM']['noP
 
 } else {
 
+  // Methods that can provoke distribution or must return the logical, not
+  // composed tree.
   forwardMethods(DomApiNative.prototype, [
     'cloneNode', 'appendChild', 'insertBefore', 'removeChild',
     'replaceChild', 'setAttribute', 'removeAttribute',
     'querySelector', 'querySelectorAll'
   ]);
 
+  // Properties that should return the logical, not composed tree. Note, `classList`
+  // is here only for legacy compatibility since it does not trigger distribution
+  // in v1 Shadow DOM.
   forwardReadOnlyProperties(DomApiNative.prototype, [
     'parentNode', 'firstChild', 'lastChild',
     'nextSibling', 'previousSibling', 'firstElementChild',

From e8c24ff4f590fe67196b152cddccacbefba417e3 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 14:55:57 -0800
Subject: [PATCH 04/29] Use set and clear debouncer upon completion. Fixes
 #5250.

---
 lib/utils/debounce.js   | 36 +++++++++++++++++++++++++++++++
 lib/utils/flush.js      | 28 ++----------------------
 test/unit/debounce.html | 48 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 86 insertions(+), 26 deletions(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index eac7dd0ee8..cabc24f8eb 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -47,6 +47,7 @@ export class Debouncer {
     if (this.isActive()) {
       this._asyncModule.cancel(/** @type {number} */(this._timer));
       this._timer = null;
+      debouncerQueue.delete(this);
     }
   }
   /**
@@ -112,3 +113,38 @@ export class Debouncer {
     return debouncer;
   }
 }
+
+let debouncerQueue = new Set();
+
+/**
+ * Adds a `Debouncer` to a list of globally flushable tasks.
+ *
+ * @param {!Debouncer} debouncer Debouncer to enqueue
+ * @return {void}
+ */
+export const enqueueDebouncer = function(debouncer) {
+  if (debouncerQueue.has(debouncer)) {
+    debouncerQueue.delete(debouncer);
+  }
+  debouncerQueue.add(debouncer);
+};
+
+/**
+ * Flushes any enqueued debouncers
+ *
+ * @return {void}
+ */
+export const flushDebouncers = function() {
+  const didFlush = Boolean(debouncerQueue.size);
+  debouncerQueue.forEach(debouncer => {
+    try {
+      debouncer.flush();
+    } catch(e) {
+      setTimeout(() => {
+        throw e;
+      });
+    }
+  });
+  debouncerQueue = new Set();
+  return didFlush;
+};
\ No newline at end of file
diff --git a/lib/utils/flush.js b/lib/utils/flush.js
index 065a58a901..a719047010 100644
--- a/lib/utils/flush.js
+++ b/lib/utils/flush.js
@@ -11,32 +11,8 @@ import './boot.js';
 /* eslint-disable no-unused-vars */
 import { Debouncer } from '../utils/debounce.js';  // used in type annotations
 /* eslint-enable no-unused-vars */
-
-let debouncerQueue = [];
-
-/**
- * Adds a `Debouncer` to a list of globally flushable tasks.
- *
- * @param {!Debouncer} debouncer Debouncer to enqueue
- * @return {void}
- */
-export const enqueueDebouncer = function(debouncer) {
-  debouncerQueue.push(debouncer);
-};
-
-function flushDebouncers() {
-  const didFlush = Boolean(debouncerQueue.length);
-  while (debouncerQueue.length) {
-    try {
-      debouncerQueue.shift().flush();
-    } catch(e) {
-      setTimeout(() => {
-        throw e;
-      });
-    }
-  }
-  return didFlush;
-}
+import { flushDebouncers } from '../utils/debounce.js';  // used in type annotations
+export { enqueueDebouncer } from '../utils/debounce.js';  // used in type annotations
 
 /**
  * Forces several classes of asynchronously queued tasks to flush:
diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index ece33b94a4..aed0378b5b 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -33,6 +33,7 @@
 import { Polymer } from '../../polymer-legacy.js';
 import { Debouncer } from '../../lib/utils/debounce.js';
 import { microTask, timeOut, animationFrame, idlePeriod } from '../../lib/utils/async.js';
+import { enqueueDebouncer, flush } from '../../lib/utils/flush.js';
 Polymer({is: 'x-basic'});
 
 suite('debounce', function() {
@@ -209,6 +210,53 @@
     });
 
   });
+
+  suite('enqueueDebouncer & flush', function() {
+    function testEnqueue(shouldFlush, done) {
+      // Longer-running debouncer
+      const timeoutCallback = sinon.spy(() => actualCallbacks.push(timeoutCallback));
+      enqueueDebouncer(Debouncer.debounce(null, timeOut, timeoutCallback));
+      // Set of short-running debouncers enqueued in the middle of first set
+      const nestedCallbacks = new Array(150).fill().map((_, i) => sinon.spy(() =>
+        actualCallbacks.push(nestedCallbacks[i])));
+      // First set of short-running debouncers
+      const microtaskCallbacks = new Array(150).fill().map((_, i) => sinon.spy(() => {
+        actualCallbacks.push(microtaskCallbacks[i]);
+        if (i === 125) {
+          nestedCallbacks.forEach(cb => 
+            enqueueDebouncer(Debouncer.debounce(null, microTask, cb)));
+        }
+      }));
+      microtaskCallbacks.forEach(cb => 
+        enqueueDebouncer(Debouncer.debounce(null, microTask, cb)));
+      // Expect short before long
+      let expectedCallbacks;
+      const actualCallbacks = [];
+      const verify = () => {
+        actualCallbacks.forEach(cb => assert.isTrue(cb.calledOnce));
+        assert.deepEqual(expectedCallbacks, actualCallbacks);
+        done();
+      };
+      if (shouldFlush) {
+        expectedCallbacks = [timeoutCallback, ...microtaskCallbacks, ...nestedCallbacks];
+        flush();
+        // When flushing, order is order of enqueing
+        verify();
+      } else {
+        expectedCallbacks = [...microtaskCallbacks, ...nestedCallbacks, timeoutCallback];
+        timeOut.run(verify);
+      }
+    }
+
+    test('non-flushed', function(done) {
+      testEnqueue(false, done);
+    });
+
+    test('flushed', function(done) {
+      testEnqueue(true, done);
+    });
+
+  });
 });
 </script>
 </body>

From 567c10b3d40bab4f83d98947750ea6b44c44616c Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 15:57:24 -0800
Subject: [PATCH 05/29] Add comments and avoid Array.fill

---
 lib/utils/debounce.js   |  4 ++++
 test/unit/debounce.html | 24 +++++++++++++++---------
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index cabc24f8eb..12aef40242 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -123,6 +123,8 @@ let debouncerQueue = new Set();
  * @return {void}
  */
 export const enqueueDebouncer = function(debouncer) {
+  // Re-enqueued debouncers are put at the end of the queue; for Set, this
+  // means removing and re-adding, since forEach traverses insertion order
   if (debouncerQueue.has(debouncer)) {
     debouncerQueue.delete(debouncer);
   }
@@ -136,6 +138,8 @@ export const enqueueDebouncer = function(debouncer) {
  */
 export const flushDebouncers = function() {
   const didFlush = Boolean(debouncerQueue.size);
+  // If new debouncers are added while flushing, Set.forEach will ensure
+  // newly added ones are also flushed
   debouncerQueue.forEach(debouncer => {
     try {
       debouncer.flush();
diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index aed0378b5b..dfa230bce0 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -217,16 +217,22 @@
       const timeoutCallback = sinon.spy(() => actualCallbacks.push(timeoutCallback));
       enqueueDebouncer(Debouncer.debounce(null, timeOut, timeoutCallback));
       // Set of short-running debouncers enqueued in the middle of first set
-      const nestedCallbacks = new Array(150).fill().map((_, i) => sinon.spy(() =>
-        actualCallbacks.push(nestedCallbacks[i])));
+      const nestedCallbacks = [];
+      for (let i=0; i<150; i++) {
+        nestedCallbacks.push(sinon.spy(() =>
+          actualCallbacks.push(nestedCallbacks[i])));
+      }
       // First set of short-running debouncers
-      const microtaskCallbacks = new Array(150).fill().map((_, i) => sinon.spy(() => {
-        actualCallbacks.push(microtaskCallbacks[i]);
-        if (i === 125) {
-          nestedCallbacks.forEach(cb => 
-            enqueueDebouncer(Debouncer.debounce(null, microTask, cb)));
-        }
-      }));
+      const microtaskCallbacks = [];
+      for (let i=0; i<150; i++) {
+        microtaskCallbacks.push(sinon.spy(() => {
+          actualCallbacks.push(microtaskCallbacks[i]);
+          if (i === 125) {
+            nestedCallbacks.forEach(cb => 
+              enqueueDebouncer(Debouncer.debounce(null, microTask, cb)));
+          }
+        }));
+      }
       microtaskCallbacks.forEach(cb => 
         enqueueDebouncer(Debouncer.debounce(null, microTask, cb)));
       // Expect short before long

From b9d495975824479443ee4acdae21596a19e428b3 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 17:11:31 -0800
Subject: [PATCH 06/29] Fix order of flushed debouncers to match 1.x

---
 lib/utils/debounce.js   | 21 ++++++++-----
 test/unit/debounce.html | 66 ++++++++++++++++++-----------------------
 2 files changed, 43 insertions(+), 44 deletions(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index 12aef40242..83163bb762 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -45,11 +45,19 @@ export class Debouncer {
    */
   cancel() {
     if (this.isActive()) {
-      this._asyncModule.cancel(/** @type {number} */(this._timer));
+      this._cancelAsync();
       this._timer = null;
       debouncerQueue.delete(this);
     }
   }
+  /**
+   * Cancels a debouncer's async callback.
+   *
+   * @return {void}
+   */
+  _cancelAsync() {
+    this._asyncModule.cancel(/** @type {number} */(this._timer));
+  }
   /**
    * Flushes an active debouncer and returns a reference to itself.
    *
@@ -105,7 +113,9 @@ export class Debouncer {
    */
   static debounce(debouncer, asyncModule, callback) {
     if (debouncer instanceof Debouncer) {
-      debouncer.cancel();
+      // Cancel the async callback, but leave in debouncerQueue if it was
+      // enqueued, to maintain 1.x flush order
+      debouncer._cancelAsync();
     } else {
       debouncer = new Debouncer();
     }
@@ -123,14 +133,11 @@ let debouncerQueue = new Set();
  * @return {void}
  */
 export const enqueueDebouncer = function(debouncer) {
-  // Re-enqueued debouncers are put at the end of the queue; for Set, this
-  // means removing and re-adding, since forEach traverses insertion order
-  if (debouncerQueue.has(debouncer)) {
-    debouncerQueue.delete(debouncer);
-  }
   debouncerQueue.add(debouncer);
 };
 
+window.debouncerQueue = debouncerQueue;
+
 /**
  * Flushes any enqueued debouncers
  *
diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index dfa230bce0..2ecdb58eb4 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -212,56 +212,48 @@
   });
 
   suite('enqueueDebouncer & flush', function() {
-    function testEnqueue(shouldFlush, done) {
-      // Longer-running debouncer
-      const timeoutCallback = sinon.spy(() => actualCallbacks.push(timeoutCallback));
-      enqueueDebouncer(Debouncer.debounce(null, timeOut, timeoutCallback));
-      // Set of short-running debouncers enqueued in the middle of first set
-      const nestedCallbacks = [];
-      for (let i=0; i<150; i++) {
-        nestedCallbacks.push(sinon.spy(() =>
-          actualCallbacks.push(nestedCallbacks[i])));
-      }
-      // First set of short-running debouncers
-      const microtaskCallbacks = [];
-      for (let i=0; i<150; i++) {
-        microtaskCallbacks.push(sinon.spy(() => {
-          actualCallbacks.push(microtaskCallbacks[i]);
-          if (i === 125) {
-            nestedCallbacks.forEach(cb => 
-              enqueueDebouncer(Debouncer.debounce(null, microTask, cb)));
-          }
-        }));
-      }
-      microtaskCallbacks.forEach(cb => 
-        enqueueDebouncer(Debouncer.debounce(null, microTask, cb)));
-      // Expect short before long
-      let expectedCallbacks;
-      const actualCallbacks = [];
-      const verify = () => {
-        actualCallbacks.forEach(cb => assert.isTrue(cb.calledOnce));
-        assert.deepEqual(expectedCallbacks, actualCallbacks);
-        done();
+
+    const testEnqueue = (shouldFlush, done) => {
+      const actualOrder = [];
+      let i=1;
+      const enqueue = (type, {db, cb} = {}) => {
+        // cb = cb || (() => actualOrder.push(cb));
+        if (!cb) {
+          cb = (() => actualOrder.push(cb));
+          Object.defineProperty(cb, 'name', {value: `db${i}`}); i++;
+        }
+        db = Debouncer.debounce(db, type, cb);
+        enqueueDebouncer(db);
+        return {db, cb};
       };
+      const db1 = enqueue(microTask);
+      const db2 = enqueue(microTask);
+      const db3 = enqueue(timeOut);
+      const db4 = enqueue(microTask);
+      enqueue(microTask, db2);
+      enqueue(microTask, db1);
       if (shouldFlush) {
-        expectedCallbacks = [timeoutCallback, ...microtaskCallbacks, ...nestedCallbacks];
         flush();
-        // When flushing, order is order of enqueing
-        verify();
+        assert.deepEqual(actualOrder, [db1.cb, db2.cb, db3.cb, db4.cb]);
+        done();
       } else {
-        expectedCallbacks = [...microtaskCallbacks, ...nestedCallbacks, timeoutCallback];
-        timeOut.run(verify);
+        timeOut.run(() => {
+          assert.deepEqual(actualOrder, [db4.cb, db2.cb, db1.cb, db3.cb]);
+          done();
+        });
       }
-    }
+    };
 
     test('non-flushed', function(done) {
       testEnqueue(false, done);
     });
 
-    test('flushed', function(done) {
+    test.only('flushed', function(done) {
       testEnqueue(true, done);
     });
 
+    test('re-enqueued ')
+
   });
 });
 </script>

From 1526626b721e304a2e65702219d0ac6f515c4f27 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 17:14:15 -0800
Subject: [PATCH 07/29] Remove test.only

---
 test/unit/debounce.html | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index 2ecdb58eb4..bc836e9fe8 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -248,12 +248,10 @@
       testEnqueue(false, done);
     });
 
-    test.only('flushed', function(done) {
+    test('flushed', function(done) {
       testEnqueue(true, done);
     });
 
-    test('re-enqueued ')
-
   });
 });
 </script>

From b750a52dfbc9ef3b2eeae50d324eab840c463290 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 17:59:08 -0800
Subject: [PATCH 08/29] Remove debug code

---
 lib/utils/debounce.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index 83163bb762..c602239d0c 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -136,8 +136,6 @@ export const enqueueDebouncer = function(debouncer) {
   debouncerQueue.add(debouncer);
 };
 
-window.debouncerQueue = debouncerQueue;
-
 /**
  * Flushes any enqueued debouncers
  *

From be1afacc0c42dcce8cd79a6c862e0ae8ce0a6cf1 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 18:02:18 -0800
Subject: [PATCH 09/29] Re-add the queue removal in setConfig

---
 lib/utils/debounce.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index c602239d0c..2c9a42a65f 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -36,6 +36,7 @@ export class Debouncer {
     this._timer = this._asyncModule.run(() => {
       this._timer = null;
       this._callback();
+      debouncerQueue.delete(this);
     });
   }
   /**

From cc6ef0e1fcfa545058a957850f979b2ce0ab1efd Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 18:05:09 -0800
Subject: [PATCH 10/29] Remove debug code

---
 test/unit/debounce.html | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index bc836e9fe8..e27bc8b42f 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -217,11 +217,7 @@
       const actualOrder = [];
       let i=1;
       const enqueue = (type, {db, cb} = {}) => {
-        // cb = cb || (() => actualOrder.push(cb));
-        if (!cb) {
-          cb = (() => actualOrder.push(cb));
-          Object.defineProperty(cb, 'name', {value: `db${i}`}); i++;
-        }
+        cb = cb || (() => actualOrder.push(cb));
         db = Debouncer.debounce(db, type, cb);
         enqueueDebouncer(db);
         return {db, cb};

From 1e56b0e9c27be22b16c7557a1efb48ae3585523c Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 18:18:35 -0800
Subject: [PATCH 11/29] FIx lint

---
 test/unit/debounce.html | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index e27bc8b42f..9f528b6ac6 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -215,7 +215,6 @@
 
     const testEnqueue = (shouldFlush, done) => {
       const actualOrder = [];
-      let i=1;
       const enqueue = (type, {db, cb} = {}) => {
         cb = cb || (() => actualOrder.push(cb));
         db = Debouncer.debounce(db, type, cb);

From b63c887f2d396d3f7f6329a301ad30d9c7ff58e2 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 27 Feb 2019 18:32:28 -0800
Subject: [PATCH 12/29] Add comment about flush order when re-debouncing

---
 lib/utils/debounce.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index 2c9a42a65f..6cafd8cb47 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -48,6 +48,10 @@ export class Debouncer {
     if (this.isActive()) {
       this._cancelAsync();
       this._timer = null;
+      // Canceling a debouncer removes its spot from the flush queue,
+      // so if a debouncer is manually canceled and re-debounced, it
+      // will reset its flush order (this is a very minor difference from 1.x)
+      // Re-debouncing via the `debounce` API retains the 1.x FIFO flush order
       debouncerQueue.delete(this);
     }
   }

From 0d0da5696715e9986d1d624186a91f5ece47e0ce Mon Sep 17 00:00:00 2001
From: Peter Burns <rictic@google.com>
Date: Mon, 4 Mar 2019 15:27:50 -0800
Subject: [PATCH 13/29] Fix/suppress upcoming JSCompiler build errors

Upstreaming cl/236195240 from the jscompiler team.

These errors come from the compiler incorrectly overriding JSDoc on a declaration with its right-hand-side. In some cases the JSDoc should not have been there; in other cases the JSDoc was correct and this reveals an error elsewhere.
---
 lib/utils/gestures.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/utils/gestures.js b/lib/utils/gestures.js
index 54b2173717..7b4bda4655 100644
--- a/lib/utils/gestures.js
+++ b/lib/utils/gestures.js
@@ -178,9 +178,10 @@ let mouseCanceller = function(mouseEvent) {
     for (let i = 0; i < path.length; i++) {
       if (path[i].nodeType === Node.ELEMENT_NODE) {
         if (path[i].localName === 'label') {
-          clickedLabels.push(path[i]);
+          clickedLabels.push(/** @type {!HTMLLabelElement} */ (path[i]));
         } else if (canBeLabelled(path[i])) {
-          let ownerLabels = matchingLabels(path[i]);
+          let ownerLabels =
+              matchingLabels(/** @type {!HTMLElement} */ (path[i]));
           // check if one of the clicked labels is labelling this element
           for (let j = 0; j < ownerLabels.length; j++) {
             clickFromLabel = clickFromLabel || clickedLabels.indexOf(ownerLabels[j]) > -1;
@@ -386,7 +387,7 @@ export function deepTargetFind(x, y) {
  * @return {EventTarget} Returns the event target.
  */
 function _findOriginalTarget(ev) {
-  const path = getComposedPath(ev);
+  const path = getComposedPath(/** @type {?Event} */ev);
   // It shouldn't be, but sometimes path is empty (window on Safari).
   return path.length > 0 ? path[0] : ev.target;
 }

From bc258d6f9df9091c2467ac61d5ea6bdf677f38a0 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 5 Mar 2019 16:12:07 -0800
Subject: [PATCH 14/29] Allow value to merge from previous behavior property
 declaration. Fixes #5503

---
 lib/legacy/class.js      | 25 +++++++++++++++++++++++--
 test/unit/behaviors.html | 14 +++++++-------
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/lib/legacy/class.js b/lib/legacy/class.js
index bb4326e370..77eb4fb690 100644
--- a/lib/legacy/class.js
+++ b/lib/legacy/class.js
@@ -155,6 +155,27 @@ function flattenBehaviors(behaviors, list, exclude) {
   return list;
 }
 
+/**
+ * Copies property descriptors from source to target, overwriting all fields
+ * of any previous descriptor for a property *except* for `value`, which is
+ * merged in from the target if it does not exist on the source.
+ * 
+ * @param {*} target Target properties object
+ * @param {*} source Source properties object
+ */
+function mergeProperties(target, source) {
+  for (const p in source) {
+    const targetInfo = target[p];
+    const value = targetInfo && targetInfo.value;
+    const sourceInfo = source[p];
+    if (sourceInfo.value === undefined && value !== undefined) {
+      target[p] = Object.assign({value}, sourceInfo);
+    } else {
+      target[p] = sourceInfo;
+    }
+  }
+}
+
 /* Note about construction and extension of legacy classes.
   [Changed in Q4 2018 to optimize performance.]
 
@@ -227,10 +248,10 @@ function GenerateClassFromInfo(info, Base, behaviors) {
       const properties = {};
       if (behaviorList) {
         for (let i=0; i < behaviorList.length; i++) {
-          Object.assign(properties, behaviorList[i].properties);
+          mergeProperties(properties, behaviorList[i].properties);
         }
       }
-      Object.assign(properties, info.properties);
+      mergeProperties(properties, info.properties);
       return properties;
     }
 
diff --git a/test/unit/behaviors.html b/test/unit/behaviors.html
index 33bdc92497..993ab0a3db 100644
--- a/test/unit/behaviors.html
+++ b/test/unit/behaviors.html
@@ -402,15 +402,15 @@
       behaviors: [
         {
           properties: {
-            foo: { value: true },
-            bar: { value: true}
+            foo: { value: 'a' },
+            bar: { value: 'a'}
           }
         },
         {
           properties: {
-            foo: { value: true },
+            foo: { value: 'b' },
             bar: String,
-            zot: {value: true}
+            zot: {value: 'b'}
           }
         },
 
@@ -587,9 +587,9 @@
 
   test('behavior default values can be overridden', function() {
     const el = fixture('override-default-value');
-    assert.notOk(el.foo);
-    assert.notOk(el.bar);
-    assert.notOk(el.zot);
+    assert.equal(el.foo, 'b');
+    assert.equal(el.bar, 'a');
+    assert.equal(el.zot, 'b');
   });
 
   test('readOnly not applied when property was previously observed', function() {

From c467c34570afc5ca0be2f55a13fc1b3e642c846e Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 5 Mar 2019 16:59:22 -0800
Subject: [PATCH 15/29] Use in check rather than undefined.

---
 lib/legacy/class.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/legacy/class.js b/lib/legacy/class.js
index 77eb4fb690..a35c0c5c84 100644
--- a/lib/legacy/class.js
+++ b/lib/legacy/class.js
@@ -166,10 +166,9 @@ function flattenBehaviors(behaviors, list, exclude) {
 function mergeProperties(target, source) {
   for (const p in source) {
     const targetInfo = target[p];
-    const value = targetInfo && targetInfo.value;
     const sourceInfo = source[p];
-    if (sourceInfo.value === undefined && value !== undefined) {
-      target[p] = Object.assign({value}, sourceInfo);
+    if (!('value' in sourceInfo) && targetInfo && ('value' in targetInfo)) {
+      target[p] = Object.assign({value: targetInfo.value}, sourceInfo);
     } else {
       target[p] = sourceInfo;
     }

From 62cf9d98a3207fe7d2061b536ea14e69ceb41f57 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 5 Mar 2019 17:38:21 -0800
Subject: [PATCH 16/29] Add extra test

---
 test/unit/behaviors.html | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/test/unit/behaviors.html b/test/unit/behaviors.html
index 993ab0a3db..6af4b6512b 100644
--- a/test/unit/behaviors.html
+++ b/test/unit/behaviors.html
@@ -403,14 +403,16 @@
         {
           properties: {
             foo: { value: 'a' },
-            bar: { value: 'a'}
+            bar: { value: 'a' },
+            ziz: { value: 'a' }
           }
         },
         {
           properties: {
             foo: { value: 'b' },
             bar: String,
-            zot: {value: 'b'}
+            zot: { value: 'b' },
+            ziz: { value: 'b' }
           }
         },
 
@@ -418,7 +420,8 @@
 
       properties: {
         foo: String,
-        zot: String
+        zot: String,
+        ziz: { value: 'c' }
       }
     });
 
@@ -590,6 +593,7 @@
     assert.equal(el.foo, 'b');
     assert.equal(el.bar, 'a');
     assert.equal(el.zot, 'b');
+    assert.equal(el.ziz, 'c');
   });
 
   test('readOnly not applied when property was previously observed', function() {

From f13dd75f9c58d6885f6b077e9199fa7f64320756 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 5 Mar 2019 18:06:59 -0800
Subject: [PATCH 17/29] Fix getStyle definition

---
 lib/elements/custom-style.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/elements/custom-style.js b/lib/elements/custom-style.js
index 2bba4de8ab..447e03e439 100644
--- a/lib/elements/custom-style.js
+++ b/lib/elements/custom-style.js
@@ -75,7 +75,7 @@ export class CustomStyle extends HTMLElement {
    * @export
    * @return {HTMLStyleElement} This element's light-DOM `<style>`
    */
-  'getStyle'() {
+  ['getStyle']() {
     if (this._style) {
       return this._style;
     }

From 03aec686e43338cf45faea1b25930d6933295f61 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 5 Mar 2019 18:31:39 -0800
Subject: [PATCH 18/29] Revert to `getStyle()`

---
 lib/elements/custom-style.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/elements/custom-style.js b/lib/elements/custom-style.js
index 447e03e439..f675393118 100644
--- a/lib/elements/custom-style.js
+++ b/lib/elements/custom-style.js
@@ -75,7 +75,7 @@ export class CustomStyle extends HTMLElement {
    * @export
    * @return {HTMLStyleElement} This element's light-DOM `<style>`
    */
-  ['getStyle']() {
+  getStyle() {
     if (this._style) {
       return this._style;
     }

From eb725f7f4de0d678c6b8c912a889d138f59bd547 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 6 Mar 2019 11:14:08 -0800
Subject: [PATCH 19/29] Fix a couple of closure type issues. * gestures -
 update internal type changes * debounce - fix mistaken return type

---
 lib/utils/debounce.js | 2 +-
 lib/utils/gestures.js | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index 6cafd8cb47..622e22d35e 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -144,7 +144,7 @@ export const enqueueDebouncer = function(debouncer) {
 /**
  * Flushes any enqueued debouncers
  *
- * @return {void}
+ * @return {boolean} Returns whether any debouncers were flushed
  */
 export const flushDebouncers = function() {
   const didFlush = Boolean(debouncerQueue.size);
diff --git a/lib/utils/gestures.js b/lib/utils/gestures.js
index 7b4bda4655..f5f4bfd680 100644
--- a/lib/utils/gestures.js
+++ b/lib/utils/gestures.js
@@ -179,7 +179,7 @@ let mouseCanceller = function(mouseEvent) {
       if (path[i].nodeType === Node.ELEMENT_NODE) {
         if (path[i].localName === 'label') {
           clickedLabels.push(/** @type {!HTMLLabelElement} */ (path[i]));
-        } else if (canBeLabelled(path[i])) {
+        } else if (canBeLabelled(/** @type {!HTMLElement} */ (path[i]))) {
           let ownerLabels =
               matchingLabels(/** @type {!HTMLElement} */ (path[i]));
           // check if one of the clicked labels is labelling this element
@@ -387,7 +387,7 @@ export function deepTargetFind(x, y) {
  * @return {EventTarget} Returns the event target.
  */
 function _findOriginalTarget(ev) {
-  const path = getComposedPath(/** @type {?Event} */ev);
+  const path = getComposedPath(/** @type {?Event} */ (ev));
   // It shouldn't be, but sometimes path is empty (window on Safari).
   return path.length > 0 ? path[0] : ev.target;
 }

From fed97654aef63740b5031e1587613ca3817f26a2 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 7 Mar 2019 12:51:18 -0800
Subject: [PATCH 20/29] Ensure the debouncer is not already canceled before
 canceling.

---
 lib/utils/debounce.js   |  6 ++-
 test/unit/debounce.html | 90 ++++++++++++++++++++++++-----------------
 2 files changed, 57 insertions(+), 39 deletions(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index 622e22d35e..6fb246052b 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -47,7 +47,6 @@ export class Debouncer {
   cancel() {
     if (this.isActive()) {
       this._cancelAsync();
-      this._timer = null;
       // Canceling a debouncer removes its spot from the flush queue,
       // so if a debouncer is manually canceled and re-debounced, it
       // will reset its flush order (this is a very minor difference from 1.x)
@@ -61,7 +60,10 @@ export class Debouncer {
    * @return {void}
    */
   _cancelAsync() {
-    this._asyncModule.cancel(/** @type {number} */(this._timer));
+    if (this.isActive()) {
+      this._asyncModule.cancel(/** @type {number} */(this._timer));
+      this._timer = null;
+    }
   }
   /**
    * Flushes an active debouncer and returns a reference to itself.
diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index 9f528b6ac6..f4d9cd3d78 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -36,6 +36,59 @@
 import { enqueueDebouncer, flush } from '../../lib/utils/flush.js';
 Polymer({is: 'x-basic'});
 
+suite('enqueueDebouncer & flush', function() {
+
+  // NOTE: This is a regression test; the bug it fixed only occured if the
+  // debouncer was flushed before any microtasks run, hence it should be
+  // first in this file.
+  test('re-enqueue canceled debouncer', function() {
+    const cb = sinon.spy();
+    let db;
+    db = Debouncer.debounce(null, microTask, cb);
+    enqueueDebouncer(db);
+    db.cancel();
+    assert.equal(db.isActive(), false);
+    assert.equal(cb.callCount, 0);
+    db = Debouncer.debounce(db, microTask, cb);
+    enqueueDebouncer(db);
+  });
+
+  const testEnqueue = (shouldFlush, done) => {
+    const actualOrder = [];
+    const enqueue = (type, {db, cb} = {}) => {
+      cb = cb || (() => actualOrder.push(cb));
+      db = Debouncer.debounce(db, type, cb);
+      enqueueDebouncer(db);
+      return {db, cb};
+    };
+    const db1 = enqueue(microTask);
+    const db2 = enqueue(microTask);
+    const db3 = enqueue(timeOut);
+    const db4 = enqueue(microTask);
+    enqueue(microTask, db2);
+    enqueue(microTask, db1);
+    if (shouldFlush) {
+      flush();
+      assert.deepEqual(actualOrder, [db1.cb, db2.cb, db3.cb, db4.cb]);
+      done();
+    } else {
+      timeOut.run(() => {
+        assert.deepEqual(actualOrder, [db4.cb, db2.cb, db1.cb, db3.cb]);
+        done();
+      });
+    }
+  };
+
+  test('non-flushed', function(done) {
+    testEnqueue(false, done);
+  });
+
+  test('flushed', function(done) {
+    testEnqueue(true, done);
+  });
+
+});
+
 suite('debounce', function() {
   var element;
 
@@ -211,43 +264,6 @@
 
   });
 
-  suite('enqueueDebouncer & flush', function() {
-
-    const testEnqueue = (shouldFlush, done) => {
-      const actualOrder = [];
-      const enqueue = (type, {db, cb} = {}) => {
-        cb = cb || (() => actualOrder.push(cb));
-        db = Debouncer.debounce(db, type, cb);
-        enqueueDebouncer(db);
-        return {db, cb};
-      };
-      const db1 = enqueue(microTask);
-      const db2 = enqueue(microTask);
-      const db3 = enqueue(timeOut);
-      const db4 = enqueue(microTask);
-      enqueue(microTask, db2);
-      enqueue(microTask, db1);
-      if (shouldFlush) {
-        flush();
-        assert.deepEqual(actualOrder, [db1.cb, db2.cb, db3.cb, db4.cb]);
-        done();
-      } else {
-        timeOut.run(() => {
-          assert.deepEqual(actualOrder, [db4.cb, db2.cb, db1.cb, db3.cb]);
-          done();
-        });
-      }
-    };
-
-    test('non-flushed', function(done) {
-      testEnqueue(false, done);
-    });
-
-    test('flushed', function(done) {
-      testEnqueue(true, done);
-    });
-
-  });
 });
 </script>
 </body>

From d48336d61493056569cbbbb7f03609ec7d341779 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 7 Mar 2019 14:56:56 -0800
Subject: [PATCH 21/29] Assert the callback was called.

---
 test/unit/debounce.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index f4d9cd3d78..5d20439147 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -40,7 +40,7 @@
 
   // NOTE: This is a regression test; the bug it fixed only occured if the
   // debouncer was flushed before any microtasks run, hence it should be
-  // first in this file.
+  // first in this file
   test('re-enqueue canceled debouncer', function() {
     const cb = sinon.spy();
     let db;
@@ -51,6 +51,8 @@
     assert.equal(cb.callCount, 0);
     db = Debouncer.debounce(db, microTask, cb);
     enqueueDebouncer(db);
+    flush();
+    assert.isTrue(cb.calledOnce);
   });
 
   const testEnqueue = (shouldFlush, done) => {

From 3b164761a791e371981ffa47c1df4ea477f1d4ba Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 12 Mar 2019 17:32:29 -0700
Subject: [PATCH 22/29] Don't clear set at end for flush reentrancy safety;
 canceling removes from set

---
 lib/utils/debounce.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index 6fb246052b..bd6f6dd7d2 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -161,6 +161,5 @@ export const flushDebouncers = function() {
       });
     }
   });
-  debouncerQueue = new Set();
   return didFlush;
 };
\ No newline at end of file

From a23ac645619a9ced1dc26ae3ae0a7d742c82f07e Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 12 Mar 2019 18:28:44 -0700
Subject: [PATCH 23/29] Ensure debouncer is removed from queue before running
 callback.

---
 lib/utils/debounce.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/utils/debounce.js b/lib/utils/debounce.js
index bd6f6dd7d2..cf4311abbc 100644
--- a/lib/utils/debounce.js
+++ b/lib/utils/debounce.js
@@ -35,8 +35,8 @@ export class Debouncer {
     this._callback = callback;
     this._timer = this._asyncModule.run(() => {
       this._timer = null;
-      this._callback();
       debouncerQueue.delete(this);
+      this._callback();
     });
   }
   /**

From 5886be5da947179c72d9280ae1aa74acbef7a73d Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 12 Mar 2019 18:28:55 -0700
Subject: [PATCH 24/29] Add tests.

---
 test/unit/debounce.html | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index 5d20439147..2d770bb611 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -38,7 +38,7 @@
 
 suite('enqueueDebouncer & flush', function() {
 
-  // NOTE: This is a regression test; the bug it fixed only occured if the
+  // NOTE: This is a regression test; the bug it fixed only occurred if the
   // debouncer was flushed before any microtasks run, hence it should be
   // first in this file
   test('re-enqueue canceled debouncer', function() {
@@ -55,6 +55,16 @@
     assert.isTrue(cb.calledOnce);
   });
 
+  test('flushDebouncers from enqueued debouncer', function(done) {
+    const cb = sinon.spy(() => flush());
+    let db = Debouncer.debounce(null, microTask, cb);
+    enqueueDebouncer(db);
+    setTimeout(() => {
+      assert.isTrue(cb.calledOnce);
+      done();
+    })
+  });
+
   const testEnqueue = (shouldFlush, done) => {
     const actualOrder = [];
     const enqueue = (type, {db, cb} = {}) => {
@@ -89,6 +99,21 @@
     testEnqueue(true, done);
   });
 
+  test('reentrant flush', function() {
+    const cb2 = sinon.spy();
+    let db2;
+    const cb1 = sinon.spy(() => {
+      flush();
+      db2 = Debouncer.debounce(null, microTask, cb2);
+      enqueueDebouncer(db2);
+    });
+    const db1 = Debouncer.debounce(null, microTask, cb1);
+    enqueueDebouncer(db1);
+    flush();
+    assert.isTrue(cb1.calledOnce);
+    assert.isTrue(cb2.calledOnce);
+  });
+
 });
 
 suite('debounce', function() {

From 4cd703335fb0901c4d92da0d6200fd857fae3916 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 12 Mar 2019 23:20:31 -0700
Subject: [PATCH 25/29] Fix lint

---
 test/unit/debounce.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/unit/debounce.html b/test/unit/debounce.html
index 2d770bb611..a5a97d599c 100644
--- a/test/unit/debounce.html
+++ b/test/unit/debounce.html
@@ -62,7 +62,7 @@
     setTimeout(() => {
       assert.isTrue(cb.calledOnce);
       done();
-    })
+    });
   });
 
   const testEnqueue = (shouldFlush, done) => {

From dc8805714478a5ccee52d6241bc5dd3de65e3dd7 Mon Sep 17 00:00:00 2001
From: David van der Leij <davidvanderleij@gmail.com>
Date: Wed, 13 Mar 2019 12:40:51 +0100
Subject: [PATCH 26/29] Remove Google+ links in README.md and CONTRIBUTING.MD

---
 CONTRIBUTING.md | 1 -
 README.md       | 1 -
 2 files changed, 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d99bb10b79..d2e675bab4 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -10,7 +10,6 @@ Beyond GitHub, we try to have a variety of different lines of communication open
 
 * [Blog](https://blog.polymer-project.org/)
 * [Twitter](https://twitter.com/polymer)
-* [Google+ Community](https://plus.sandbox.google.com/u/0/communities/115626364525706131031?cfem=1)
 * [Mailing list](https://groups.google.com/forum/#!forum/polymer-dev)
 * [Slack channel](https://bit.ly/polymerslack)
 
diff --git a/README.md b/README.md
index 58a54a8a2d..b65a090bd4 100644
--- a/README.md
+++ b/README.md
@@ -135,7 +135,6 @@ Beyond GitHub, we try to have a variety of different lines of communication avai
 
 * [Blog](https://blog.polymer-project.org/)
 * [Twitter](https://twitter.com/polymer)
-* [Google+ community](https://plus.google.com/communities/115626364525706131031)
 * [Mailing list](https://groups.google.com/forum/#!forum/polymer-dev)
 * [Slack channel](https://bit.ly/polymerslack)
 

From 48769c4bc86d1d3ea20d04cdf39ffdc99e12da99 Mon Sep 17 00:00:00 2001
From: Daniel Freedman <dfreedm@google.com>
Date: Thu, 21 Mar 2019 15:40:10 -0700
Subject: [PATCH 27/29] [ci skip] update polymer version

---
 lib/mixins/element-mixin.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mixins/element-mixin.js b/lib/mixins/element-mixin.js
index c931fb7fc0..af291ac45b 100644
--- a/lib/mixins/element-mixin.js
+++ b/lib/mixins/element-mixin.js
@@ -24,7 +24,7 @@ import { wrap } from '../utils/wrap.js';
  * Current Polymer version in Semver notation.
  * @type {string} Semver notation of the current version of Polymer.
  */
-export const version = '3.0.5';
+export const version = '3.2.0';
 
 const builtCSS = window.ShadyCSS && window.ShadyCSS['cssBuild'];
 

From bffe1793dc2125694526d70dd39898efd7ef4d14 Mon Sep 17 00:00:00 2001
From: Daniel Freedman <dfreedm@google.com>
Date: Thu, 21 Mar 2019 15:41:39 -0700
Subject: [PATCH 28/29] 3.2.0

---
 package-lock.json | 2 +-
 package.json      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 18b8846d8b..1ac0035ba0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "@polymer/polymer",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
diff --git a/package.json b/package.json
index 1ccba888ec..6b89e07f24 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@polymer/polymer",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "The Polymer library makes it easy to create your own web components. Give your element some markup and properties, and then use it on a site. Polymer provides features like dynamic templates and data binding to reduce the amount of boilerplate you need to write",
   "main": "polymer-element.js",
   "directories": {

From 24d642ec97081dcc73cba81d66a014b62ebf0a27 Mon Sep 17 00:00:00 2001
From: Steven Orvell <sorvell@google.com>
Date: Wed, 27 Mar 2019 09:56:28 -0700
Subject: [PATCH 29/29] Remove use of TreeWalker for finding nodes in
 templates.

TreeWalker is slower than normal DOM accessors on Edge/IE. This change was put in place to enhance performance by avoiding ShadyDOM patches, but the recent noPatch mode is a better way to accomplish this.
---
 lib/mixins/template-stamp.js | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

diff --git a/lib/mixins/template-stamp.js b/lib/mixins/template-stamp.js
index 167fbe530a..3ae0607e01 100644
--- a/lib/mixins/template-stamp.js
+++ b/lib/mixins/template-stamp.js
@@ -11,9 +11,6 @@ import '../utils/boot.js';
 
 import { dedupingMixin } from '../utils/mixin.js';
 
-const walker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,
-    null, false);
-
 // 1.x backwards-compatible auto-wrapper for template type extensions
 // This is a clear layering violation and gives favored-nation status to
 // dom-if and dom-repeat templates.  This is a conceit we're choosing to keep
@@ -48,8 +45,7 @@ function findTemplateNode(root, nodeInfo) {
   if (parent) {
     // note: marginally faster than indexing via childNodes
     // (http://jsperf.com/childnodes-lookup)
-    walker.currentNode = parent;
-    for (let n=walker.firstChild(), i=0; n; n=walker.nextSibling()) {
+    for (let n=parent.firstChild, i=0; n; n=n.nextSibling) {
       if (nodeInfo.parentIndex === i++) {
         return n;
       }
@@ -238,8 +234,7 @@ export const TemplateStamp = dedupingMixin(
         // For ShadyDom optimization, indicating there is an insertion point
         templateInfo.hasInsertionPoint = true;
       }
-      walker.currentNode = element;
-      if (walker.firstChild()) {
+      if (element.firstChild) {
         noted = this._parseTemplateChildNodes(element, templateInfo, nodeInfo) || noted;
       }
       if (element.hasAttributes && element.hasAttributes()) {
@@ -265,8 +260,7 @@ export const TemplateStamp = dedupingMixin(
       if (root.localName === 'script' || root.localName === 'style') {
         return;
       }
-      walker.currentNode = root;
-      for (let node=walker.firstChild(), parentIndex=0, next; node; node=next) {
+      for (let node=root.firstChild, parentIndex=0, next; node; node=next) {
         // Wrap templates
         if (node.localName == 'template') {
           node = wrapTemplateExtension(node);
@@ -275,13 +269,12 @@ export const TemplateStamp = dedupingMixin(
         // text nodes to be inexplicably split =(
         // note that root.normalize() should work but does not so we do this
         // manually.
-        walker.currentNode = node;
-        next = walker.nextSibling();
+        next = node.nextSibling;
         if (node.nodeType === Node.TEXT_NODE) {
           let /** Node */ n = next;
           while (n && (n.nodeType === Node.TEXT_NODE)) {
             node.textContent += n.textContent;
-            next = walker.nextSibling();
+            next = n.nextSibling;
             root.removeChild(n);
             n = next;
           }
@@ -296,8 +289,7 @@ export const TemplateStamp = dedupingMixin(
           childInfo.infoIndex = templateInfo.nodeInfoList.push(/** @type {!NodeInfo} */(childInfo)) - 1;
         }
         // Increment if not removed
-        walker.currentNode = node;
-        if (walker.parentNode()) {
+        if (node.parentNode) {
           parentIndex++;
         }
       }