feat(promise): fix #621, add unhandledRejection handler and ignore consoleError (#627)

Author: JiaLiPassion

Diff for: lib/browser/browser.ts

@@ -7,7 +7,7 @@
  */
 
 import {patchTimer} from '../common/timers';
-import {patchClass, patchMethod, patchPrototype, zoneSymbol} from '../common/utils';
+import {findEventTask, patchClass, patchMethod, patchPrototype, zoneSymbol} from '../common/utils';
 
 import {propertyPatch} from './define-property';
 import {eventTargetPatch} from './event-target';
@@ -142,3 +142,26 @@ function patchXHR(window: any) {
 if (_global['navigator'] && _global['navigator'].geolocation) {
   patchPrototype(_global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);
 }
+
+// handle unhandled promise rejection
+function findPromiseRejectionHandler(evtName: string) {
+  return function(e: any) {
+    const eventTask = findEventTask(_global, evtName);
+    if (eventTask) {
+      // windows has added unhandledrejection event listener
+      // trigger the event listener
+      const PromiseRejectionEvent = _global['PromiseRejectionEvent'];
+      if (PromiseRejectionEvent) {
+        const evt = new PromiseRejectionEvent(evtName, {promise: e.promise, reason: e.rejection});
+        eventTask.invoke(evt);
+      }
+    }
+  };
+}
+
+if (_global['PromiseRejectionEvent']) {
+  Zone[zoneSymbol('unhandledPromiseRejectionHandler')] =
+      findPromiseRejectionHandler('unhandledrejection');
+
+  Zone[zoneSymbol('rejectionHandledHandler')] = findPromiseRejectionHandler('rejectionhandled');
+}

Diff for: lib/common/utils.ts

@@ -527,6 +527,7 @@ export interface MicroTaskMeta extends TaskData {
   callbackIndex: number;
   args: any[];
 }
+
 export function patchMicroTask(
     obj: any, funcName: string, metaCreator: (self: any, args: any[]) => MicroTaskMeta) {
   let setNative = null;
@@ -551,4 +552,19 @@ export function patchMicroTask(
       return delegate.apply(self, args);
     }
   });
-}
+}
+
+export function findEventTask(target: any, evtName: string) {
+  const eventTasks: Task[] = target[zoneSymbol('eventTasks')];
+  if (eventTasks) {
+    for (let i = 0; i < eventTasks.length; i++) {
+      const eventTask = eventTasks[i];
+      const data = eventTask.data;
+      const eventName = data && (<any>data).eventName;
+      if (eventName === evtName) {
+        return eventTask;
+      }
+    }
+  }
+  return undefined;
+}

Diff for: lib/node/node.ts

@@ -11,7 +11,7 @@ import './events';
 import './fs';
 
 import {patchTimer} from '../common/timers';
-import {patchMacroTask, patchMethod, patchMicroTask} from '../common/utils';
+import {findEventTask, patchMacroTask, patchMicroTask, zoneSymbol} from '../common/utils';
 
 const set = 'set';
 const clear = 'clear';
@@ -33,6 +33,7 @@ if (shouldPatchGlobalTimers) {
 
 // patch process related methods
 patchProcess();
+handleUnhandledPromiseRejection();
 
 // Crypto
 let crypto;
@@ -67,4 +68,28 @@ function patchProcess() {
       target: process
     };
   });
-}
+}
+
+// handle unhandled promise rejection
+function findProcessPromiseRejectionHandler(evtName: string) {
+  return function(e: any) {
+    const eventTask = findEventTask(process, evtName);
+    if (eventTask) {
+      // process has added unhandledrejection event listener
+      // trigger the event listener
+      if (evtName === 'unhandledRejection') {
+        eventTask.invoke(e.rejection, e.promise);
+      } else if (evtName === 'rejectionHandled') {
+        eventTask.invoke(e.promise);
+      }
+    }
+  };
+}
+
+function handleUnhandledPromiseRejection() {
+  Zone[zoneSymbol('unhandledPromiseRejectionHandler')] =
+      findProcessPromiseRejectionHandler('unhandledRejection');
+
+  Zone[zoneSymbol('rejectionHandledHandler')] =
+      findProcessPromiseRejectionHandler('rejectionHandled');
+}

Diff for: lib/zone.ts

@@ -1041,6 +1041,9 @@ const Zone: ZoneType = (function(global: any) {
   }
 
   function consoleError(e: any) {
+    if (Zone[__symbol__('ignoreConsoleErrorUncaughtError')]) {
+      return;
+    }
     const rejection = e && e.rejection;
     if (rejection) {
       console.error(
@@ -1052,6 +1055,17 @@ const Zone: ZoneType = (function(global: any) {
     console.error(e);
   }
 
+  function handleUnhandledRejection(e: any) {
+    consoleError(e);
+    try {
+      const handler = Zone[__symbol__('unhandledPromiseRejectionHandler')];
+      if (handler && typeof handler === 'function') {
+        handler.apply(this, [e]);
+      }
+    } catch (err) {
+    }
+  }
+
   function drainMicroTaskQueue() {
     if (!_isDrainingMicrotaskQueue) {
       _isDrainingMicrotaskQueue = true;
@@ -1075,7 +1089,7 @@ const Zone: ZoneType = (function(global: any) {
               throw uncaughtPromiseError;
             });
           } catch (error) {
-            consoleError(error);
+            handleUnhandledRejection(error);
           }
         }
       }
@@ -1196,11 +1210,22 @@ const Zone: ZoneType = (function(global: any) {
 
   function clearRejectedNoCatch(promise: ZoneAwarePromise<any>): void {
     if (promise[symbolState] === REJECTED_NO_CATCH) {
+      // if the promise is rejected no catch status
+      // and queue.length > 0, means there is a error handler
+      // here to handle the rejected promise, we should trigger
+      // windows.rejectionhandled eventHandler or nodejs rejectionHandled
+      // eventHandler
+      try {
+        const handler = Zone[__symbol__('rejectionHandledHandler')];
+        if (handler && typeof handler === 'function') {
+          handler.apply(this, [{rejection: promise[symbolValue], promise: promise}]);
+        }
+      } catch (err) {
+      }
       promise[symbolState] = REJECTED;
       for (let i = 0; i < _uncaughtPromiseErrors.length; i++) {
         if (promise === _uncaughtPromiseErrors[i].promise) {
           _uncaughtPromiseErrors.splice(i, 1);
-          break;
         }
       }
     }

Diff for: promise-adapter.js

@@ -1,5 +1,5 @@
 require('./dist/zone-node.js');
-
+Zone[('__zone_symbol__ignoreConsoleErrorUncaughtError')] = true;
 module.exports.deferred = function() {
   const p = {};
   p.promise = new Promise((resolve, reject) => {

Diff for: test/browser/browser.spec.ts

@@ -6,12 +6,17 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {zoneSymbol} from '../../lib/common/utils';
 import {ifEnvSupports} from '../test-util';
 
 function windowPrototype() {
   return !!(global['Window'] && global['Window'].prototype);
 }
 
+function promiseUnhandleRejectionSupport() {
+  return !!global['PromiseRejectionEvent'];
+}
+
 describe('Zone', function() {
   const rootZone = Zone.current;
 
@@ -142,6 +147,52 @@ describe('Zone', function() {
           expect(button.onclick).not.toBe(null);
         });
       });
+
+      it('should support window.addEventListener(unhandledrejection)', function(done) {
+        if (!promiseUnhandleRejectionSupport()) {
+          done();
+          return;
+        }
+        Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
+        rootZone.fork({name: 'promise'}).run(function() {
+          const listener = (evt: any) => {
+            expect(evt.type).toEqual('unhandledrejection');
+            expect(evt.promise.constructor.name).toEqual('Promise');
+            expect(evt.reason.message).toBe('promise error');
+            window.removeEventListener('unhandledrejection', listener);
+            done();
+          };
+          window.addEventListener('unhandledrejection', listener);
+          new Promise((resolve, reject) => {
+            throw new Error('promise error');
+          });
+        });
+      });
+
+      it('should support window.addEventListener(rejectionhandled)', function(done) {
+        if (!promiseUnhandleRejectionSupport()) {
+          done();
+          return;
+        }
+        Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
+        rootZone.fork({name: 'promise'}).run(function() {
+          const listener = (evt: any) => {
+            window.removeEventListener('unhandledrejection', listener);
+            p.catch(reason => {});
+          };
+          window.addEventListener('unhandledrejection', listener);
+
+          window.addEventListener('rejectionhandled', (evt: any) => {
+            expect(evt.type).toEqual('rejectionhandled');
+            expect(evt.promise.constructor.name).toEqual('Promise');
+            expect(evt.reason.message).toBe('promise error');
+            done();
+          });
+          const p = new Promise((resolve, reject) => {
+            throw new Error('promise error');
+          });
+        });
+      });
     });
   });
 });

Diff for: test/node/process.spec.ts

@@ -6,6 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {zoneSymbol} from '../../lib/common/utils';
+
 describe('process related test', () => {
   let zoneA, result;
   beforeEach(() => {
@@ -62,4 +64,38 @@ describe('process related test', () => {
       done();
     });
   });
+  it('should support window.addEventListener(unhandledrejection)', function(done) {
+    const hookSpy = jasmine.createSpy('hook');
+    Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
+    Zone.current.fork({name: 'promise'}).run(function() {
+      process.on('unhandledRejection', function(reason, promise) {
+        hookSpy(promise, reason.message);
+      });
+      const p = new Promise((resolve, reject) => {
+        throw new Error('promise error');
+      });
+
+      setTimeout(function() {
+        expect(hookSpy).toHaveBeenCalledWith(p, 'promise error');
+        done();
+      }, 10);
+    });
+  });
+
+  it('should support window.addEventListener(rejectionHandled)', function(done) {
+    Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
+    Zone.current.fork({name: 'promise'}).run(function() {
+      process.on('rejectionHandled', function(promise) {
+        expect(promise).toEqual(p);
+        done();
+      });
+      const p = new Promise((resolve, reject) => {
+        throw new Error('promise error');
+      });
+
+      setTimeout(function() {
+        p.catch(reason => {});
+      }, 10);
+    });
+  });
 });