Update charted to 0.4.8 and roll

packages/stack_trace/test/chain/vm_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.
 
 // VM chain tests can rely on stronger guarantees about the contents of the
 // stack traces than dart2js.
 @TestOn('dart-vm')
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 import 'package:test/test.dart';
 
 import '../utils.dart';
 import 'utils.dart';
 
 void main() {
   group('capture() with onError catches exceptions', () {
     test('thrown synchronously', () {
-      return captureFuture(() => throw 'error')
-          .then((chain) {
+      return captureFuture(() => throw 'error').then((chain) {
         expect(chain.traces, hasLength(1));
-        expect(chain.traces.single.frames.first,
-            frameMember(startsWith('main')));
+        expect(
+            chain.traces.single.frames.first, frameMember(startsWith('main')));
       });
     });
 
     test('thrown in a microtask', () {
       return captureFuture(() => inMicrotask(() => throw 'error'))
           .then((chain) {
         // Since there was only one asynchronous operation, there should be only
         // two traces in the chain.
         expect(chain.traces, hasLength(2));
 
@@ skipping 307 matching lines @@
 
       return completer.future.then((chain) {
         expect(chain.traces, hasLength(2));
         expect(chain.traces[0].frames.first, frameMember(startsWith('main')));
         expect(chain.traces[1].frames,
             contains(frameMember(startsWith('inFutureChain'))));
       });
     });
   });
 
-  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(() {
+    // The test runner runs all tests with chains enabled.
+    return Chain.disable(() {
       var completer = new Completer();
       inMicrotask(() => completer.complete(new Chain.current()));
 
       return completer.future.then((chain) {
         // 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));
-        expect(chain.traces.first.frames.first,
-            frameMember(startsWith('main')));
+        expect(
+            chain.traces.first.frames.first, frameMember(startsWith('main')));
       });
-    }, zoneValues: {#stack_trace.stack_zone.spec: null});
+    });
   });
 
   group('forTrace() within capture()', () {
     test('called for a stack trace from a microtask', () {
       return Chain.capture(() {
         return chainForTrace(inMicrotask, () => throw 'error');
       }).then((chain) {
         // Because [chainForTrace] has to set up a future chain to capture the
         // stack trace while still showing it to the zone specification, it adds
         // an additional level of async nesting and so an additional trace.
@@ skipping 25 matching lines @@
       }).then((chain) {
         expect(chain.traces, hasLength(3));
         expect(chain.traces[0].frames.first, frameMember(startsWith('main')));
         expect(chain.traces[1].frames,
             contains(frameMember(startsWith('chainForTrace'))));
         expect(chain.traces[2].frames,
             contains(frameMember(startsWith('inPeriodicTimer'))));
       });
     });
 
-    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', () {
       return Chain.capture(() {
         return chainForTrace((callback) {
           inPeriodicTimer(() => inOneShotTimer(() => inMicrotask(callback)));
         }, () => throw 'error');
       }).then((chain) {
         expect(chain.traces, hasLength(5));
         expect(chain.traces[0].frames.first, frameMember(startsWith('main')));
         expect(chain.traces[1].frames,
             contains(frameMember(startsWith('chainForTrace'))));
@@ skipping 12 matching lines @@
       }).then((chain) {
         expect(chain.traces, hasLength(3));
         expect(chain.traces[0].frames.first, frameMember(startsWith('main')));
         expect(chain.traces[1].frames,
             contains(frameMember(startsWith('chainForTrace'))));
         expect(chain.traces[2].frames,
             contains(frameMember(startsWith('inFutureChain'))));
       });
     });
 
-    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()));
   });
 }