From 90caa2bc55254c18ce2281b4994f4ec2e6283cec Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 23 Jun 2015 20:13:49 -0700
Subject: [PATCH 1/4] Catch errors in async queue & re-start. Fixes #1933.
 Fixes #1759.

---
 src/lib/async.html   | 70 +++++++++++++++++++++++---------------------
 test/unit/async.html | 41 +++++++++++++++++++++++++-
 2 files changed, 76 insertions(+), 35 deletions(-)
diff --git a/src/lib/async.html b/src/lib/async.html
index 652bf53c82..7cce5d6331 100644
--- a/src/lib/async.html
+++ b/src/lib/async.html
@@ -9,60 +9,62 @@
 -->
 <script>
 
-Polymer.Async = (function() {
-  
-  var currVal = 0;
-  var lastVal = 0;
-  var callbacks = [];
-  var twiddle = document.createTextNode('');
+Polymer.Async = {
 
-  function runAsync(callback, waitTime) {
+  _currVal: 0,
+  _lastVal: 0,
+  _callbacks: [],
+  _twiddleContent: 0,
+  _twiddle: document.createTextNode(''),
+
+  run: function (callback, waitTime) {
     if (waitTime > 0) {
       return ~setTimeout(callback, waitTime);
     } else {
-      twiddle.textContent = currVal++;
-      callbacks.push(callback);
-      return currVal - 1;
+      this._twiddle.textContent = this._twiddleContent++;
+      this._callbacks.push(callback);
+      return this._currVal++;
     }
-  }
+  },
 
-  function cancelAsync(handle) {
+  cancel: function(handle) {
     if (handle < 0) {
       clearTimeout(~handle);
     } else {
-      var idx = handle - lastVal;
+      var idx = handle - this._lastVal;
       if (idx >= 0) {
-        if (!callbacks[idx]) {
+        if (!this._callbacks[idx]) {
           throw 'invalid async handle: ' + handle;
         }
-        callbacks[idx] = null;
+        this._callbacks[idx] = null;
       }
     }
-  }
+  },
 
-  function atEndOfMicrotask() {
-    var len = callbacks.length;
+  _atEndOfMicrotask: function() {
+    var len = this._callbacks.length;
     for (var i=0; i<len; i++) {
-      var cb = callbacks[i];
+      var cb = this._callbacks[i];
       if (cb) {
-        cb();
+        try {
+          cb();
+        } catch(e) {
+          // Clear queue up to this point & start over after throwing
+          i++;
+          this._callbacks.splice(0, i);
+          this._lastVal += i;
+          this._twiddle.textContent = this._twiddleContent++;
+          throw e;
+        }
       }
     }
-    callbacks.splice(0, len);
-    lastVal += len;
+    this._callbacks.splice(0, len);
+    this._lastVal += len;
   }
+};
 
-  new (window.MutationObserver || JsMutationObserver)(atEndOfMicrotask)
-    .observe(twiddle, {characterData: true})
-    ;
-  
-  // exports 
-
-  return {
-    run: runAsync,
-    cancel: cancelAsync
-  };
-  
-})();
+new (window.MutationObserver || JsMutationObserver)
+  (Polymer.Async._atEndOfMicrotask.bind(Polymer.Async))
+  .observe(Polymer.Async._twiddle, {characterData: true});
 
 </script>
diff --git a/test/unit/async.html b/test/unit/async.html
index 58fc1ac20e..5ca2154c79 100644
--- a/test/unit/async.html
+++ b/test/unit/async.html
@@ -19,7 +19,7 @@
 <body>
 
 <script>
-  
+
   setup(function() {
     window.Async = Polymer.Async;
   });
@@ -80,6 +80,45 @@
       });
     });
 
+    test('error handling', function(done) {
+      var called1 = 0;
+      var called2 = 0;
+      var called3 = 0;
+      var called4 = 0;
+      var callback1 = function() {
+        called1++;
+      };
+      var callback2 = function() {
+        called2++;
+        throw new Error('intentional error 2');
+      };
+      var callback3 = function() {
+        called3++;
+        throw new Error('intentional error 2');
+      };
+      var callback4 = function() {
+        called4++;
+      };
+      Async.run(callback1);
+      Async.run(callback2);
+      Async.run(callback3);
+      Async.run(callback4);
+      // Force synchronous microtask, since we can't catch the error otherwise
+      assert.throws(function(done) {
+        Async._atEndOfMicrotask();
+      });
+      assert.throws(function(done) {
+        Async._atEndOfMicrotask();
+      });
+      setTimeout(function() {
+        assert.equal(called1, 1);
+        assert.equal(called2, 1);
+        assert.equal(called3, 1);
+        assert.equal(called4, 1);
+        done();
+      });
+    });
+
   });
 
   suite('cancel no-wait async', function() {

From 3d70f0c1e3ff5d006d48db9240cea6ced2945686 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 23 Jun 2015 20:14:37 -0700
Subject: [PATCH 2/4] Typo.

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

diff --git a/test/unit/async.html b/test/unit/async.html
index 5ca2154c79..32157acb00 100644
--- a/test/unit/async.html
+++ b/test/unit/async.html
@@ -90,7 +90,7 @@
       };
       var callback2 = function() {
         called2++;
-        throw new Error('intentional error 2');
+        throw new Error('intentional error 1');
       };
       var callback3 = function() {
         called3++;

From 35fb3c7bd94079d1d3b2cd73708265ff534ca9e9 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 24 Jun 2015 15:06:13 -0700
Subject: [PATCH 3/4] Refactor test to be stricter.

---
 test/unit/async.html | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/unit/async.html b/test/unit/async.html
index 32157acb00..e6ed494bb4 100644
--- a/test/unit/async.html
+++ b/test/unit/async.html
@@ -104,16 +104,16 @@
       Async.run(callback3);
       Async.run(callback4);
       // Force synchronous microtask, since we can't catch the error otherwise
-      assert.throws(function(done) {
+      assert.throws(function() {
         Async._atEndOfMicrotask();
       });
-      assert.throws(function(done) {
+      assert.equal(called1, 1);
+      assert.equal(called2, 1);
+      assert.throws(function() {
         Async._atEndOfMicrotask();
       });
+      assert.equal(called3, 1);
       setTimeout(function() {
-        assert.equal(called1, 1);
-        assert.equal(called2, 1);
-        assert.equal(called3, 1);
         assert.equal(called4, 1);
         done();
       });

From d07e5cf7b9277412b2de491de35b7f6151d2546b Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 24 Jun 2015 15:14:19 -0700
Subject: [PATCH 4/4] More test.

---
 test/unit/async.html | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/test/unit/async.html b/test/unit/async.html
index e6ed494bb4..3093694193 100644
--- a/test/unit/async.html
+++ b/test/unit/async.html
@@ -85,6 +85,7 @@
       var called2 = 0;
       var called3 = 0;
       var called4 = 0;
+      var called5 = 0;
       var callback1 = function() {
         called1++;
       };
@@ -94,11 +95,15 @@
       };
       var callback3 = function() {
         called3++;
+        Async.run(callback5);
         throw new Error('intentional error 2');
       };
       var callback4 = function() {
         called4++;
       };
+      var callback5 = function() {
+        called5++;
+      };
       Async.run(callback1);
       Async.run(callback2);
       Async.run(callback3);
@@ -107,14 +112,32 @@
       assert.throws(function() {
         Async._atEndOfMicrotask();
       });
+      // Have been called
       assert.equal(called1, 1);
       assert.equal(called2, 1);
+      // Not yet called, due to exception
+      assert.equal(called3, 0);
+      assert.equal(called4, 0);
+      assert.equal(called5, 0);
+      // Force next synchronous microtask
       assert.throws(function() {
         Async._atEndOfMicrotask();
       });
+      // Have been called
+      assert.equal(called1, 1);
+      assert.equal(called2, 1);
       assert.equal(called3, 1);
+      // Not yet called, due to exception
+      assert.equal(called4, 0);
+      assert.equal(called5, 0);
+      // Wait for actual microtask, and verify remaining queue was flushed
       setTimeout(function() {
+        // Have been called
+        assert.equal(called1, 1);
+        assert.equal(called2, 1);
+        assert.equal(called3, 1);
         assert.equal(called4, 1);
+        assert.equal(called5, 1);
         done();
       });
     });
