feat(core): update zone.js to 0.8.10 and expose the flush method (#16860)

`flush()` can now be used from within fakeAsync tests to simulate moving
time forward until all macrotask events have been cleared from the
event queue.

packages/core/test/fake_async_spec.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {discardPeriodicTasks, fakeAsync, flushMicrotasks, tick} from '@angular/core/testing';
+import {discardPeriodicTasks, fakeAsync, flush, flushMicrotasks, tick} from '@angular/core/testing';
 import {Log, beforeEach, describe, inject, it} from '@angular/core/testing/src/testing_internal';
 import {expect} from '@angular/platform-browser/testing/src/matchers';
 
@@ -261,6 +261,42 @@ export function main() {
                    'microtask; timer; t microtask; periodic timer; pt microtask; periodic timer; pt microtask');
            clearInterval(id);
          }));
+
+      it('should flush tasks', fakeAsync(() => {
+           let ran = false;
+           setTimeout(() => { ran = true; }, 10);
+
+           flush();
+           expect(ran).toEqual(true);
+         }));
+
+      it('should flush multiple tasks', fakeAsync(() => {
+           let ran = false;
+           let ran2 = false;
+           setTimeout(() => { ran = true; }, 10);
+           setTimeout(() => { ran2 = true; }, 30);
+
+           let elapsed = flush();
+
+           expect(ran).toEqual(true);
+           expect(ran2).toEqual(true);
+           expect(elapsed).toEqual(30);
+         }));
+
+      it('should move periodic tasks', fakeAsync(() => {
+           let ran = false;
+           let count = 0;
+           setInterval(() => { count++; }, 10);
+           setTimeout(() => { ran = true; }, 35);
+
+           let elapsed = flush();
+
+           expect(count).toEqual(3);
+           expect(ran).toEqual(true);
+           expect(elapsed).toEqual(35);
+
+           discardPeriodicTasks();
+         }));
     });
 
     describe('outside of the fakeAsync zone', () => {
@@ -276,6 +312,12 @@ export function main() {
         }).toThrowError('The code should be running in the fakeAsync zone to call this function');
       });
 
+      it('calling flush should throw', () => {
+        expect(() => {
+          flush();
+        }).toThrowError('The code should be running in the fakeAsync zone to call this function');
+      });
+
       it('calling discardPeriodicTasks should throw', () => {
         expect(() => {
           discardPeriodicTasks();

packages/core/testing/src/fake_async.ts

@@ -115,6 +115,20 @@ export function tick(millis: number = 0): void {
   _getFakeAsyncZoneSpec().tick(millis);
 }
 
+/**
+ * Simulates the asynchronous passage of time for the timers in the fakeAsync zone by
+ * draining the macrotask queue until it is empty. The returned value is the milliseconds
+ * of time that would have been elapsed.
+ *
+ * @param maxTurns
+ * @returns {number} The simulated time elapsed, in millis.
+ *
+ * @experimental
+ */
+export function flush(maxTurns?: number): number {
+  return _getFakeAsyncZoneSpec().flush(maxTurns);
+}
+
 /**
  * Discard all remaining periodic tasks.
  *