Update charted to 0.4.8 and roll

packages/stack_trace/test/chain/dart2js_test.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // dart2js chain tests are separated out because dart2js stack traces are
 // inconsistent due to inlining and browser differences. These tests don't
 // assert anything about the content of the traces, just the number of traces in
 // a chain.
 @TestOn('js')
 
@@ skipping 10 matching lines @@
       var chain = await captureFuture(() => throw 'error');
       expect(chain.traces, hasLength(1));
     });
 
     test('thrown in a microtask', () async {
       var chain = await captureFuture(() => inMicrotask(() => throw 'error'));
       expect(chain.traces, hasLength(2));
     });
 
     test('thrown in a one-shot timer', () async {
-      var chain = await captureFuture(
-          () => inOneShotTimer(() => throw 'error'));
+      var chain =
+          await captureFuture(() => inOneShotTimer(() => throw 'error'));
       expect(chain.traces, hasLength(2));
     });
 
     test('thrown in a periodic timer', () async {
-      var chain = await captureFuture(
-          () => inPeriodicTimer(() => throw 'error'));
+      var chain =
+          await captureFuture(() => inPeriodicTimer(() => throw 'error'));
       expect(chain.traces, hasLength(2));
     });
 
     test('thrown in a nested series of asynchronous operations', () async {
       var chain = await captureFuture(() {
         inPeriodicTimer(() {
           inOneShotTimer(() => inMicrotask(() => throw 'error'));
         });
       });
 
@@ skipping 182 matching lines @@
       var completer = new Completer();
       Chain.capture(() {
         inFutureChain(() => completer.complete(new Chain.current()));
       });
 
       var chain = await completer.future;
       expect(chain.traces, hasLength(2));
     });
   });
 
-  test('current() outside of capture() returns a chain wrapping the current '
+  test(
+      'current() outside of capture() returns a chain wrapping the current '
       'trace', () {
-    // The test runner runs all tests with chains enabled, so to test without we
-    // have to do some zone munging.
-    return runZoned(() async {
+    // The test runner runs all tests with chains enabled.
+    return Chain.disable(() async {
       var completer = new Completer();
       inMicrotask(() => completer.complete(new Chain.current()));
 
       var chain = await completer.future;
       // Since the chain wasn't loaded within [Chain.capture], the full stack
       // chain isn't available and it just returns the current stack when
       // called.
       expect(chain.traces, hasLength(1));
-    }, zoneValues: {#stack_trace.stack_zone.spec: null});
+    });
   });
 
   group('forTrace() within capture()', () {
     test('called for a stack trace from a microtask', () async {
       var chain = await Chain.capture(() {
         return chainForTrace(inMicrotask, () => throw 'error');
       });
 
       // Because [chainForTrace] has to set up a future chain to capture the
       // stack trace while still showing it to the zone specification, it adds
@@ skipping 10 matching lines @@
     });
 
     test('called for a stack trace from a periodic timer', () async {
       var chain = await Chain.capture(() {
         return chainForTrace(inPeriodicTimer, () => throw 'error');
       });
 
       expect(chain.traces, hasLength(3));
     });
 
-    test('called for a stack trace from a nested series of asynchronous '
+    test(
+        'called for a stack trace from a nested series of asynchronous '
         'operations', () async {
       var chain = await Chain.capture(() {
         return chainForTrace((callback) {
           inPeriodicTimer(() => inOneShotTimer(() => inMicrotask(callback)));
         }, () => throw 'error');
       });
 
       expect(chain.traces, hasLength(5));
     });
 
     test('called for a stack trace from a long future chain', () async {
       var chain = await Chain.capture(() {
         return chainForTrace(inFutureChain, () => throw 'error');
       });
 
       expect(chain.traces, hasLength(3));
     });
 
-    test('called for an unregistered stack trace returns a chain wrapping that '
+    test(
+        'called for an unregistered stack trace returns a chain wrapping that '
         'trace', () {
       var trace;
       var chain = Chain.capture(() {
         try {
           throw 'error';
         } catch (_, stackTrace) {
           trace = stackTrace;
           return new Chain.forTrace(stackTrace);
         }
       });
 
       expect(chain.traces, hasLength(1));
       expect(chain.traces.first.toString(),
           equals(new Trace.from(trace).toString()));
     });
   });
 
-  test('forTrace() outside of capture() returns a chain wrapping the given '
+  test(
+      'forTrace() outside of capture() returns a chain wrapping the given '
       'trace', () {
     var trace;
     var chain = Chain.capture(() {
       try {
         throw 'error';
       } catch (_, stackTrace) {
         trace = stackTrace;
         return new Chain.forTrace(stackTrace);
       }
     });
 
     expect(chain.traces, hasLength(1));
     expect(chain.traces.first.toString(),
         equals(new Trace.from(trace).toString()));
   });
 }