Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(662)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/dart_codegen/expect/async/zone.dart

Issue 963593002: Disable formatting and add new-lines to make tests faster. (Closed) Base URL: git@github.com:dart-lang/dev_compiler.git@master
Patch Set: Created 5 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« test/dart_codegen/expect/_internal/iterable.dart ('K') | « test/dart_codegen/expect/async/timer.dart ('k') | test/dart_codegen/expect/collection/collection » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 part of dart.async; 1 part of dart.async;
2 2 typedef dynamic ZoneCallback();
3 typedef dynamic ZoneCallback(); 3 typedef dynamic ZoneUnaryCallback(arg);
4 typedef dynamic ZoneUnaryCallback(arg); 4 typedef dynamic ZoneBinaryCallback(arg1, arg2);
5 typedef dynamic ZoneBinaryCallback(arg1, arg2); 5 typedef dynamic HandleUncaughtErrorHandler(Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace);
6 typedef dynamic HandleUncaughtErrorHandler( 6 typedef dynamic RunHandler(Zone self, ZoneDelegate parent, Zone zone, f());
7 Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace); 7 typedef dynamic RunUnaryHandler(Zone self, ZoneDelegate parent, Zone zone, f(ar g), arg);
8 typedef dynamic RunHandler(Zone self, ZoneDelegate parent, Zone zone, f()); 8 typedef dynamic RunBinaryHandler(Zone self, ZoneDelegate parent, Zone zone, f(a rg1, arg2), arg1, arg2);
9 typedef dynamic RunUnaryHandler( 9 typedef ZoneCallback RegisterCallbackHandler(Zone self, ZoneDelegate parent, Zo ne zone, f());
10 Zone self, ZoneDelegate parent, Zone zone, f(arg), arg); 10 typedef ZoneUnaryCallback RegisterUnaryCallbackHandler(Zone self, ZoneDelegate parent, Zone zone, f(arg));
11 typedef dynamic RunBinaryHandler( 11 typedef ZoneBinaryCallback RegisterBinaryCallbackHandler(Zone self, ZoneDelegat e parent, Zone zone, f(arg1, arg2));
12 Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2), arg1, arg2); 12 typedef AsyncError ErrorCallbackHandler(Zone self, ZoneDelegate parent, Zone zo ne, Object error, StackTrace stackTrace);
13 typedef ZoneCallback RegisterCallbackHandler( 13 typedef void ScheduleMicrotaskHandler(Zone self, ZoneDelegate parent, Zone zone , f());
14 Zone self, ZoneDelegate parent, Zone zone, f()); 14 typedef Timer CreateTimerHandler(Zone self, ZoneDelegate parent, Zone zone, Dur ation duration, void f());
15 typedef ZoneUnaryCallback RegisterUnaryCallbackHandler( 15 typedef Timer CreatePeriodicTimerHandler(Zone self, ZoneDelegate parent, Zone z one, Duration period, void f(Timer timer));
16 Zone self, ZoneDelegate parent, Zone zone, f(arg)); 16 typedef void PrintHandler(Zone self, ZoneDelegate parent, Zone zone, String lin e);
17 typedef ZoneBinaryCallback RegisterBinaryCallbackHandler( 17 typedef Zone ForkHandler(Zone self, ZoneDelegate parent, Zone zone, ZoneSpecifi cation specification, Map zoneValues);
18 Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)); 18 class AsyncError implements Error {final error;
19 typedef AsyncError ErrorCallbackHandler(Zone self, ZoneDelegate parent, 19 final StackTrace stackTrace;
20 Zone zone, Object error, StackTrace stackTrace); 20 AsyncError(this.error, this.stackTrace);
21 typedef void ScheduleMicrotaskHandler( 21 String toString() => ((__x133) => DDC$RT.cast(__x133, dynamic, String, "CastGen eral", """line 46, column 24 of dart:async/zone.dart: """, __x133 is String, tru e))(error.toString());
22 Zone self, ZoneDelegate parent, Zone zone, f()); 22 }
23 typedef Timer CreateTimerHandler( 23 class _ZoneFunction {final _Zone zone;
24 Zone self, ZoneDelegate parent, Zone zone, Duration duration, void f()); 24 final Function function;
25 typedef Timer CreatePeriodicTimerHandler(Zone self, ZoneDelegate parent, 25 const _ZoneFunction(this.zone, this.function);
26 Zone zone, Duration period, void f(Timer timer)); 26 }
27 typedef void PrintHandler( 27 abstract class ZoneSpecification {const factory ZoneSpecification({
28 Zone self, ZoneDelegate parent, Zone zone, String line); 28 dynamic handleUncaughtError(Zone self, ZoneDelegate parent, Zone zone, error, St ackTrace stackTrace), dynamic run(Zone self, ZoneDelegate parent, Zone zone, f() ), dynamic runUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg), dyn amic runBinary(Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2), arg1, a rg2), ZoneCallback registerCallback(Zone self, ZoneDelegate parent, Zone zone, f ()), ZoneUnaryCallback registerUnaryCallback(Zone self, ZoneDelegate parent, Zon e zone, f(arg)), ZoneBinaryCallback registerBinaryCallback(Zone self, ZoneDelega te parent, Zone zone, f(arg1, arg2)), AsyncError errorCallback(Zone self, ZoneDe legate parent, Zone zone, Object error, StackTrace stackTrace), void scheduleMic rotask(Zone self, ZoneDelegate parent, Zone zone, f()), Timer createTimer(Zone s elf, ZoneDelegate parent, Zone zone, Duration duration, void f()), Timer createP eriodicTimer(Zone self, ZoneDelegate parent, Zone zone, Duration period, void f( Timer timer)), void print(Zone self, ZoneDelegate parent, Zone zone, String line ), Zone fork(Zone self, ZoneDelegate parent, Zone zone, ZoneSpecification specif ication, Map zoneValues)}
29 typedef Zone ForkHandler(Zone self, ZoneDelegate parent, Zone zone, 29 ) = _ZoneSpecification;
30 ZoneSpecification specification, Map zoneValues); 30 factory ZoneSpecification.from(ZoneSpecification other, {
31 class AsyncError implements Error { 31 dynamic handleUncaughtError(Zone self, ZoneDelegate parent, Zone zone, error, St ackTrace stackTrace) : null, dynamic run(Zone self, ZoneDelegate parent, Zone zo ne, f()) : null, dynamic runUnary(Zone self, ZoneDelegate parent, Zone zone, f(a rg), arg) : null, dynamic runBinary(Zone self, ZoneDelegate parent, Zone zone, f (arg1, arg2), arg1, arg2) : null, ZoneCallback registerCallback(Zone self, ZoneD elegate parent, Zone zone, f()) : null, ZoneUnaryCallback registerUnaryCallback( Zone self, ZoneDelegate parent, Zone zone, f(arg)) : null, ZoneBinaryCallback re gisterBinaryCallback(Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)) : null, AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone, Objec t error, StackTrace stackTrace), void scheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) : null, Timer createTimer(Zone self, ZoneDelegate parent , Zone zone, Duration duration, void f()) : null, Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone, Duration period, void f(Timer timer)) : n ull, void print(Zone self, ZoneDelegate parent, Zone zone, String line) : null, Zone fork(Zone self, ZoneDelegate parent, Zone zone, ZoneSpecification specifica tion, Map zoneValues) : null}
32 final error; 32 ) {
33 final StackTrace stackTrace; 33 return new ZoneSpecification(handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other. run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: runBinar y != null ? runBinary : other.runBinary, registerCallback: registerCallback != n ull ? registerCallback : other.registerCallback, registerUnaryCallback: register UnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, reg isterBinaryCallback: registerBinaryCallback != null ? registerBinaryCallback : o ther.registerBinaryCallback, errorCallback: errorCallback != null ? errorCallbac k : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? schedule Microtask : other.scheduleMicrotask, createTimer: createTimer != null ? createTi mer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? crea tePeriodicTimer : other.createPeriodicTimer, print: print != null ? print : othe r.print, fork: fork != null ? fork : other.fork);
34 AsyncError(this.error, this.stackTrace); 34 }
35 String toString() => ((__x133) => DDC$RT.cast(__x133, dynamic, String, 35 HandleUncaughtErrorHandler get handleUncaughtError;
36 "CastGeneral", """line 46, column 24 of dart:async/zone.dart: """, 36 RunHandler get run;
37 __x133 is String, true))(error.toString()); 37 RunUnaryHandler get runUnary;
38 } 38 RunBinaryHandler get runBinary;
39 class _ZoneFunction { 39 RegisterCallbackHandler get registerCallback;
40 final _Zone zone; 40 RegisterUnaryCallbackHandler get registerUnaryCallback;
41 final Function function; 41 RegisterBinaryCallbackHandler get registerBinaryCallback;
42 const _ZoneFunction(this.zone, this.function); 42 ErrorCallbackHandler get errorCallback;
43 } 43 ScheduleMicrotaskHandler get scheduleMicrotask;
44 abstract class ZoneSpecification { 44 CreateTimerHandler get createTimer;
45 const factory ZoneSpecification({dynamic handleUncaughtError(Zone self, 45 CreatePeriodicTimerHandler get createPeriodicTimer;
46 ZoneDelegate parent, Zone zone, error, StackTrace stackTrace), 46 PrintHandler get print;
47 dynamic run(Zone self, ZoneDelegate parent, Zone zone, f()), 47 ForkHandler get fork;
48 dynamic runUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg), 48 }
49 dynamic runBinary( 49 class _ZoneSpecification implements ZoneSpecification {const _ZoneSpecification ({
50 Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2), arg1, arg2), 50 this.handleUncaughtError : null, this.run : null, this.runUnary : null, this.run Binary : null, this.registerCallback : null, this.registerUnaryCallback : null, this.registerBinaryCallback : null, this.errorCallback : null, this.scheduleMicr otask : null, this.createTimer : null, this.createPeriodicTimer : null, this.pri nt : null, this.fork : null}
51 ZoneCallback registerCallback( 51 );
52 Zone self, ZoneDelegate parent, Zone zone, f()), 52 final handleUncaughtError;
53 ZoneUnaryCallback registerUnaryCallback( 53 final run;
54 Zone self, ZoneDelegate parent, Zone zone, f(arg)), 54 final runUnary;
55 ZoneBinaryCallback registerBinaryCallback( 55 final runBinary;
56 Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)), 56 final registerCallback;
57 AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone, 57 final registerUnaryCallback;
58 Object error, StackTrace stackTrace), 58 final registerBinaryCallback;
59 void scheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()), 59 final errorCallback;
60 Timer createTimer(Zone self, ZoneDelegate parent, Zone zone, 60 final scheduleMicrotask;
61 Duration duration, void f()), Timer createPeriodicTimer(Zone self, 61 final createTimer;
62 ZoneDelegate parent, Zone zone, Duration period, void f(Timer timer)), 62 final createPeriodicTimer;
63 void print(Zone self, ZoneDelegate parent, Zone zone, String line), 63 final print;
64 Zone fork(Zone self, ZoneDelegate parent, Zone zone, 64 final fork;
65 ZoneSpecification specification, 65 }
66 Map zoneValues)}) = _ZoneSpecification; 66 abstract class ZoneDelegate {dynamic handleUncaughtError(Zone zone, error, Stac kTrace stackTrace);
67 factory ZoneSpecification.from(ZoneSpecification other, 67 dynamic run(Zone zone, f());
68 {dynamic handleUncaughtError(Zone self, ZoneDelegate parent, Zone zone, 68 dynamic runUnary(Zone zone, f(arg), arg);
69 error, StackTrace stackTrace): null, 69 dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2);
70 dynamic run(Zone self, ZoneDelegate parent, Zone zone, f()): null, 70 ZoneCallback registerCallback(Zone zone, f());
71 dynamic runUnary( 71 ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg));
72 Zone self, ZoneDelegate parent, Zone zone, f(arg), arg): null, 72 ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2));
73 dynamic runBinary(Zone self, ZoneDelegate parent, Zone zone, 73 AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace);
74 f(arg1, arg2), arg1, arg2): null, ZoneCallback registerCallback( 74 void scheduleMicrotask(Zone zone, f());
75 Zone self, ZoneDelegate parent, Zone zone, f()): null, 75 Timer createTimer(Zone zone, Duration duration, void f());
76 ZoneUnaryCallback registerUnaryCallback( 76 Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer));
77 Zone self, ZoneDelegate parent, Zone zone, f(arg)): null, 77 void print(Zone zone, String line);
78 ZoneBinaryCallback registerBinaryCallback( 78 Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues);
79 Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)): null, 79 }
80 AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone, 80 abstract class Zone {Zone._();
81 Object error, StackTrace stackTrace), void scheduleMicrotask( 81 static const Zone ROOT = _ROOT_ZONE;
82 Zone self, ZoneDelegate parent, Zone zone, f()): null, 82 static Zone _current = DDC$RT.cast(_ROOT_ZONE, dynamic, Zone, "CastGeneral", "" "line 262, column 26 of dart:async/zone.dart: """, _ROOT_ZONE is Zone, true);
83 Timer createTimer(Zone self, ZoneDelegate parent, Zone zone, 83 static Zone get current => _current;
84 Duration duration, void f()): null, Timer createPeriodicTimer( 84 dynamic handleUncaughtError(error, StackTrace stackTrace);
85 Zone self, ZoneDelegate parent, Zone zone, Duration period, 85 Zone get parent;
86 void f(Timer timer)): null, 86 Zone get errorZone;
87 void print(Zone self, ZoneDelegate parent, Zone zone, String line): null, 87 bool inSameErrorZone(Zone otherZone);
88 Zone fork(Zone self, ZoneDelegate parent, Zone zone, 88 Zone fork({
89 ZoneSpecification specification, Map zoneValues): null}) { 89 ZoneSpecification specification, Map zoneValues}
90 return new ZoneSpecification( 90 );
91 handleUncaughtError: handleUncaughtError != null 91 dynamic run(f());
92 ? handleUncaughtError 92 dynamic runUnary(f(arg), var arg);
93 : other.handleUncaughtError, 93 dynamic runBinary(f(arg1, arg2), var arg1, var arg2);
94 run: run != null ? run : other.run, 94 dynamic runGuarded(f());
95 runUnary: runUnary != null ? runUnary : other.runUnary, 95 dynamic runUnaryGuarded(f(arg), var arg);
96 runBinary: runBinary != null ? runBinary : other.runBinary, 96 dynamic runBinaryGuarded(f(arg1, arg2), var arg1, var arg2);
97 registerCallback: registerCallback != null 97 ZoneCallback registerCallback(callback());
98 ? registerCallback 98 ZoneUnaryCallback registerUnaryCallback(callback(arg));
99 : other.registerCallback, 99 ZoneBinaryCallback registerBinaryCallback(callback(arg1, arg2));
100 registerUnaryCallback: registerUnaryCallback != null 100 ZoneCallback bindCallback(f(), {
101 ? registerUnaryCallback 101 bool runGuarded : true}
102 : other.registerUnaryCallback, 102 );
103 registerBinaryCallback: registerBinaryCallback != null 103 ZoneUnaryCallback bindUnaryCallback(f(arg), {
104 ? registerBinaryCallback 104 bool runGuarded : true}
105 : other.registerBinaryCallback, 105 );
106 errorCallback: errorCallback != null 106 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), {
107 ? errorCallback 107 bool runGuarded : true}
108 : other.errorCallback, 108 );
109 scheduleMicrotask: scheduleMicrotask != null 109 AsyncError errorCallback(Object error, StackTrace stackTrace);
110 ? scheduleMicrotask 110 void scheduleMicrotask(void f());
111 : other.scheduleMicrotask, 111 Timer createTimer(Duration duration, void callback());
112 createTimer: createTimer != null ? createTimer : other.createTimer, 112 Timer createPeriodicTimer(Duration period, void callback(Timer timer));
113 createPeriodicTimer: createPeriodicTimer != null 113 void print(String line);
114 ? createPeriodicTimer 114 static Zone _enter(Zone zone) {
115 : other.createPeriodicTimer, 115 assert (zone != null); assert (!identical(zone, _current)); Zone previous = _cur rent;
116 print: print != null ? print : other.print, 116 _current = zone;
117 fork: fork != null ? fork : other.fork); 117 return previous;
118 } 118 }
119 HandleUncaughtErrorHandler get handleUncaughtError; 119 static void _leave(Zone previous) {
120 RunHandler get run; 120 assert (previous != null); Zone._current = previous;
121 RunUnaryHandler get runUnary; 121 }
122 RunBinaryHandler get runBinary; 122 operator [](Object key);
123 RegisterCallbackHandler get registerCallback; 123 }
124 RegisterUnaryCallbackHandler get registerUnaryCallback; 124 ZoneDelegate _parentDelegate(_Zone zone) {
125 RegisterBinaryCallbackHandler get registerBinaryCallback; 125 if (zone.parent == null) return null;
126 ErrorCallbackHandler get errorCallback; 126 return zone.parent._delegate;
127 ScheduleMicrotaskHandler get scheduleMicrotask; 127 }
128 CreateTimerHandler get createTimer; 128 class _ZoneDelegate implements ZoneDelegate {final _Zone _delegationTarget;
129 CreatePeriodicTimerHandler get createPeriodicTimer; 129 _ZoneDelegate(this._delegationTarget);
130 PrintHandler get print; 130 dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace) {
131 ForkHandler get fork; 131 _ZoneFunction implementation = _delegationTarget._handleUncaughtError;
132 } 132 _Zone implZone = implementation.zone;
133 class _ZoneSpecification implements ZoneSpecification { 133 return (implementation.function)(implZone, _parentDelegate(implZone), zone, err or, stackTrace);
134 const _ZoneSpecification({this.handleUncaughtError: null, this.run: null, 134 }
135 this.runUnary: null, this.runBinary: null, this.registerCallback: null, 135 dynamic run(Zone zone, f()) {
136 this.registerUnaryCallback: null, this.registerBinaryCallback: null, 136 _ZoneFunction implementation = _delegationTarget._run;
137 this.errorCallback: null, this.scheduleMicrotask: null, 137 _Zone implZone = implementation.zone;
138 this.createTimer: null, this.createPeriodicTimer: null, this.print: null, 138 return (implementation.function)(implZone, _parentDelegate(implZone), zone, f);
139 this.fork: null}); 139 }
140 final handleUncaughtError; 140 dynamic runUnary(Zone zone, f(arg), arg) {
141 final run; 141 _ZoneFunction implementation = _delegationTarget._runUnary;
142 final runUnary; 142 _Zone implZone = implementation.zone;
143 final runBinary; 143 return (implementation.function)(implZone, _parentDelegate(implZone), zone, f, arg);
144 final registerCallback; 144 }
145 final registerUnaryCallback; 145 dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2) {
146 final registerBinaryCallback; 146 _ZoneFunction implementation = _delegationTarget._runBinary;
147 final errorCallback; 147 _Zone implZone = implementation.zone;
148 final scheduleMicrotask; 148 return (implementation.function)(implZone, _parentDelegate(implZone), zone, f, arg1, arg2);
149 final createTimer; 149 }
150 final createPeriodicTimer; 150 ZoneCallback registerCallback(Zone zone, f()) {
151 final print; 151 _ZoneFunction implementation = _delegationTarget._registerCallback;
152 final fork; 152 _Zone implZone = implementation.zone;
153 } 153 return ((__x135) => DDC$RT.cast(__x135, dynamic, __t134, "CastGeneral", """line 522, column 12 of dart:async/zone.dart: """, __x135 is __t134, false))((impleme ntation.function)(implZone, _parentDelegate(implZone), zone, f));
154 abstract class ZoneDelegate { 154 }
155 dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace); 155 ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg)) {
156 dynamic run(Zone zone, f()); 156 _ZoneFunction implementation = _delegationTarget._registerUnaryCallback;
157 dynamic runUnary(Zone zone, f(arg), arg); 157 _Zone implZone = implementation.zone;
158 dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2); 158 return ((__x138) => DDC$RT.cast(__x138, dynamic, __t136, "CastGeneral", """line 529, column 12 of dart:async/zone.dart: """, __x138 is __t136, false))((impleme ntation.function)(implZone, _parentDelegate(implZone), zone, f));
159 ZoneCallback registerCallback(Zone zone, f()); 159 }
160 ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg)); 160 ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2)) {
161 ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2)); 161 _ZoneFunction implementation = _delegationTarget._registerBinaryCallback;
162 AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace); 162 _Zone implZone = implementation.zone;
163 void scheduleMicrotask(Zone zone, f()); 163 return ((__x142) => DDC$RT.cast(__x142, dynamic, __t139, "CastGeneral", """line 536, column 12 of dart:async/zone.dart: """, __x142 is __t139, false))((impleme ntation.function)(implZone, _parentDelegate(implZone), zone, f));
164 Timer createTimer(Zone zone, Duration duration, void f()); 164 }
165 Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)); 165 AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace) {
166 void print(Zone zone, String line); 166 _ZoneFunction implementation = _delegationTarget._errorCallback;
167 Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues); 167 _Zone implZone = implementation.zone;
168 } 168 if (identical(implZone, _ROOT_ZONE)) return null;
169 abstract class Zone { 169 return ((__x143) => DDC$RT.cast(__x143, dynamic, AsyncError, "CastGeneral", """ line 544, column 12 of dart:async/zone.dart: """, __x143 is AsyncError, true))(( implementation.function)(implZone, _parentDelegate(implZone), zone, error, stack Trace));
170 Zone._(); 170 }
171 static const Zone ROOT = _ROOT_ZONE; 171 void scheduleMicrotask(Zone zone, f()) {
172 static Zone _current = DDC$RT.cast(_ROOT_ZONE, dynamic, Zone, "CastGeneral", 172 _ZoneFunction implementation = _delegationTarget._scheduleMicrotask;
173 """line 262, column 26 of dart:async/zone.dart: """, _ROOT_ZONE is Zone, 173 _Zone implZone = implementation.zone;
174 true); 174 (implementation.function)(implZone, _parentDelegate(implZone), zone, f);
175 static Zone get current => _current; 175 }
176 dynamic handleUncaughtError(error, StackTrace stackTrace); 176 Timer createTimer(Zone zone, Duration duration, void f()) {
177 Zone get parent; 177 _ZoneFunction implementation = _delegationTarget._createTimer;
178 Zone get errorZone; 178 _Zone implZone = implementation.zone;
179 bool inSameErrorZone(Zone otherZone); 179 return ((__x144) => DDC$RT.cast(__x144, dynamic, Timer, "CastGeneral", """line 558, column 12 of dart:async/zone.dart: """, __x144 is Timer, true))((implementa tion.function)(implZone, _parentDelegate(implZone), zone, duration, f));
180 Zone fork({ZoneSpecification specification, Map zoneValues}); 180 }
181 dynamic run(f()); 181 Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)) {
182 dynamic runUnary(f(arg), var arg); 182 _ZoneFunction implementation = _delegationTarget._createPeriodicTimer;
183 dynamic runBinary(f(arg1, arg2), var arg1, var arg2); 183 _Zone implZone = implementation.zone;
184 dynamic runGuarded(f()); 184 return ((__x145) => DDC$RT.cast(__x145, dynamic, Timer, "CastGeneral", """line 565, column 12 of dart:async/zone.dart: """, __x145 is Timer, true))((implementa tion.function)(implZone, _parentDelegate(implZone), zone, period, f));
185 dynamic runUnaryGuarded(f(arg), var arg); 185 }
186 dynamic runBinaryGuarded(f(arg1, arg2), var arg1, var arg2); 186 void print(Zone zone, String line) {
187 ZoneCallback registerCallback(callback()); 187 _ZoneFunction implementation = _delegationTarget._print;
188 ZoneUnaryCallback registerUnaryCallback(callback(arg)); 188 _Zone implZone = implementation.zone;
189 ZoneBinaryCallback registerBinaryCallback(callback(arg1, arg2)); 189 (implementation.function)(implZone, _parentDelegate(implZone), zone, line);
190 ZoneCallback bindCallback(f(), {bool runGuarded: true}); 190 }
191 ZoneUnaryCallback bindUnaryCallback(f(arg), {bool runGuarded: true}); 191 Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues) {
192 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), {bool runGuarded: true}); 192 _ZoneFunction implementation = _delegationTarget._fork;
193 AsyncError errorCallback(Object error, StackTrace stackTrace); 193 _Zone implZone = implementation.zone;
194 void scheduleMicrotask(void f()); 194 return ((__x146) => DDC$RT.cast(__x146, dynamic, Zone, "CastGeneral", """line 5 80, column 12 of dart:async/zone.dart: """, __x146 is Zone, true))((implementati on.function)(implZone, _parentDelegate(implZone), zone, specification, zoneValue s));
195 Timer createTimer(Duration duration, void callback()); 195 }
196 Timer createPeriodicTimer(Duration period, void callback(Timer timer)); 196 }
197 void print(String line); 197 abstract class _Zone implements Zone {const _Zone();
198 static Zone _enter(Zone zone) { 198 _ZoneFunction get _runUnary;
199 assert(zone != null); 199 _ZoneFunction get _run;
200 assert(!identical(zone, _current)); 200 _ZoneFunction get _runBinary;
201 Zone previous = _current; 201 _ZoneFunction get _registerCallback;
202 _current = zone; 202 _ZoneFunction get _registerUnaryCallback;
203 return previous; 203 _ZoneFunction get _registerBinaryCallback;
204 } 204 _ZoneFunction get _errorCallback;
205 static void _leave(Zone previous) { 205 _ZoneFunction get _scheduleMicrotask;
206 assert(previous != null); 206 _ZoneFunction get _createTimer;
207 Zone._current = previous; 207 _ZoneFunction get _createPeriodicTimer;
208 } 208 _ZoneFunction get _print;
209 operator [](Object key); 209 _ZoneFunction get _fork;
210 } 210 _ZoneFunction get _handleUncaughtError;
211 ZoneDelegate _parentDelegate(_Zone zone) { 211 _Zone get parent;
212 if (zone.parent == null) return null; 212 _ZoneDelegate get _delegate;
213 return zone.parent._delegate; 213 Map get _map;
214 } 214 bool inSameErrorZone(Zone otherZone) {
215 class _ZoneDelegate implements ZoneDelegate { 215 return identical(this, otherZone) || identical(errorZone, otherZone.errorZone);
216 final _Zone _delegationTarget; 216 }
217 _ZoneDelegate(this._delegationTarget); 217 }
218 dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace) { 218 class _CustomZone extends _Zone {_ZoneFunction _runUnary;
219 _ZoneFunction implementation = _delegationTarget._handleUncaughtError; 219 _ZoneFunction _run;
220 _Zone implZone = implementation.zone; 220 _ZoneFunction _runBinary;
221 return (implementation.function)( 221 _ZoneFunction _registerCallback;
222 implZone, _parentDelegate(implZone), zone, error, stackTrace); 222 _ZoneFunction _registerUnaryCallback;
223 } 223 _ZoneFunction _registerBinaryCallback;
224 dynamic run(Zone zone, f()) { 224 _ZoneFunction _errorCallback;
225 _ZoneFunction implementation = _delegationTarget._run; 225 _ZoneFunction _scheduleMicrotask;
226 _Zone implZone = implementation.zone; 226 _ZoneFunction _createTimer;
227 return (implementation.function)( 227 _ZoneFunction _createPeriodicTimer;
228 implZone, _parentDelegate(implZone), zone, f); 228 _ZoneFunction _print;
229 } 229 _ZoneFunction _fork;
230 dynamic runUnary(Zone zone, f(arg), arg) { 230 _ZoneFunction _handleUncaughtError;
231 _ZoneFunction implementation = _delegationTarget._runUnary; 231 ZoneDelegate _delegateCache;
232 _Zone implZone = implementation.zone; 232 final _Zone parent;
233 return (implementation.function)( 233 final Map _map;
234 implZone, _parentDelegate(implZone), zone, f, arg); 234 ZoneDelegate get _delegate {
235 } 235 if (_delegateCache != null) return _delegateCache;
236 dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2) { 236 _delegateCache = new _ZoneDelegate(this);
237 _ZoneFunction implementation = _delegationTarget._runBinary; 237 return _delegateCache;
238 _Zone implZone = implementation.zone; 238 }
239 return (implementation.function)( 239 _CustomZone(this.parent, ZoneSpecification specification, this._map) {
240 implZone, _parentDelegate(implZone), zone, f, arg1, arg2); 240 _run = (specification.run != null) ? new _ZoneFunction(this, specification.run) : parent._run;
241 } 241 _runUnary = (specification.runUnary != null) ? new _ZoneFunction(this, specific ation.runUnary) : parent._runUnary;
242 ZoneCallback registerCallback(Zone zone, f()) { 242 _runBinary = (specification.runBinary != null) ? new _ZoneFunction(this, specif ication.runBinary) : parent._runBinary;
243 _ZoneFunction implementation = _delegationTarget._registerCallback; 243 _registerCallback = (specification.registerCallback != null) ? new _ZoneFunctio n(this, specification.registerCallback) : parent._registerCallback;
244 _Zone implZone = implementation.zone; 244 _registerUnaryCallback = (specification.registerUnaryCallback != null) ? new _Z oneFunction(this, specification.registerUnaryCallback) : parent._registerUnaryCa llback;
245 return ((__x135) => DDC$RT.cast(__x135, dynamic, __t134, "CastGeneral", 245 _registerBinaryCallback = (specification.registerBinaryCallback != null) ? new _ZoneFunction(this, specification.registerBinaryCallback) : parent._registerBina ryCallback;
246 """line 522, column 12 of dart:async/zone.dart: """, 246 _errorCallback = (specification.errorCallback != null) ? new _ZoneFunction(this , specification.errorCallback) : parent._errorCallback;
247 __x135 is __t134, false))((implementation.function)( 247 _scheduleMicrotask = (specification.scheduleMicrotask != null) ? new _ZoneFunct ion(this, specification.scheduleMicrotask) : parent._scheduleMicrotask;
248 implZone, _parentDelegate(implZone), zone, f)); 248 _createTimer = (specification.createTimer != null) ? new _ZoneFunction(this, sp ecification.createTimer) : parent._createTimer;
249 } 249 _createPeriodicTimer = (specification.createPeriodicTimer != null) ? new _ZoneF unction(this, specification.createPeriodicTimer) : parent._createPeriodicTimer;
250 ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg)) { 250 _print = (specification.print != null) ? new _ZoneFunction(this, specification. print) : parent._print;
251 _ZoneFunction implementation = _delegationTarget._registerUnaryCallback; 251 _fork = (specification.fork != null) ? new _ZoneFunction(this, specification.fo rk) : parent._fork;
252 _Zone implZone = implementation.zone; 252 _handleUncaughtError = (specification.handleUncaughtError != null) ? new _ZoneF unction(this, specification.handleUncaughtError) : parent._handleUncaughtError;
253 return ((__x138) => DDC$RT.cast(__x138, dynamic, __t136, "CastGeneral", 253 }
254 """line 529, column 12 of dart:async/zone.dart: """, 254 Zone get errorZone => _handleUncaughtError.zone;
255 __x138 is __t136, false))((implementation.function)( 255 dynamic runGuarded(f()) {
256 implZone, _parentDelegate(implZone), zone, f)); 256 try {
257 } 257 return run(f);
258 ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2)) { 258 }
259 _ZoneFunction implementation = _delegationTarget._registerBinaryCallback; 259 catch (e, s) {
260 _Zone implZone = implementation.zone; 260 return handleUncaughtError(e, s);
261 return ((__x142) => DDC$RT.cast(__x142, dynamic, __t139, "CastGeneral", 261 }
262 """line 536, column 12 of dart:async/zone.dart: """, 262 }
263 __x142 is __t139, false))((implementation.function)( 263 dynamic runUnaryGuarded(f(arg), arg) {
264 implZone, _parentDelegate(implZone), zone, f)); 264 try {
265 } 265 return runUnary(f, arg);
266 AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace) { 266 }
267 _ZoneFunction implementation = _delegationTarget._errorCallback; 267 catch (e, s) {
268 _Zone implZone = implementation.zone; 268 return handleUncaughtError(e, s);
269 if (identical(implZone, _ROOT_ZONE)) return null; 269 }
270 return ((__x143) => DDC$RT.cast(__x143, dynamic, AsyncError, "CastGeneral", 270 }
271 """line 544, column 12 of dart:async/zone.dart: """, 271 dynamic runBinaryGuarded(f(arg1, arg2), arg1, arg2) {
272 __x143 is AsyncError, true))((implementation.function)( 272 try {
273 implZone, _parentDelegate(implZone), zone, error, stackTrace)); 273 return runBinary(f, arg1, arg2);
274 } 274 }
275 void scheduleMicrotask(Zone zone, f()) { 275 catch (e, s) {
276 _ZoneFunction implementation = _delegationTarget._scheduleMicrotask; 276 return handleUncaughtError(e, s);
277 _Zone implZone = implementation.zone; 277 }
278 (implementation.function)(implZone, _parentDelegate(implZone), zone, f); 278 }
279 } 279 ZoneCallback bindCallback(f(), {
280 Timer createTimer(Zone zone, Duration duration, void f()) { 280 bool runGuarded : true}
281 _ZoneFunction implementation = _delegationTarget._createTimer; 281 ) {
282 _Zone implZone = implementation.zone; 282 ZoneCallback registered = registerCallback(f);
283 return ((__x144) => DDC$RT.cast(__x144, dynamic, Timer, "CastGeneral", 283 if (runGuarded) {
284 """line 558, column 12 of dart:async/zone.dart: """, 284 return () => this.runGuarded(registered);
285 __x144 is Timer, true))((implementation.function)( 285 }
286 implZone, _parentDelegate(implZone), zone, duration, f)); 286 else {
287 } 287 return () => this.run(registered);
288 Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)) { 288 }
289 _ZoneFunction implementation = _delegationTarget._createPeriodicTimer; 289 }
290 _Zone implZone = implementation.zone; 290 ZoneUnaryCallback bindUnaryCallback(f(arg), {
291 return ((__x145) => DDC$RT.cast(__x145, dynamic, Timer, "CastGeneral", 291 bool runGuarded : true}
292 """line 565, column 12 of dart:async/zone.dart: """, 292 ) {
293 __x145 is Timer, true))((implementation.function)( 293 ZoneUnaryCallback registered = registerUnaryCallback(f);
294 implZone, _parentDelegate(implZone), zone, period, f)); 294 if (runGuarded) {
295 } 295 return (arg) => this.runUnaryGuarded(registered, arg);
296 void print(Zone zone, String line) { 296 }
297 _ZoneFunction implementation = _delegationTarget._print; 297 else {
298 _Zone implZone = implementation.zone; 298 return (arg) => this.runUnary(registered, arg);
299 (implementation.function)(implZone, _parentDelegate(implZone), zone, line); 299 }
300 } 300 }
301 Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues) { 301 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), {
302 _ZoneFunction implementation = _delegationTarget._fork; 302 bool runGuarded : true}
303 _Zone implZone = implementation.zone; 303 ) {
304 return ((__x146) => DDC$RT.cast(__x146, dynamic, Zone, "CastGeneral", 304 ZoneBinaryCallback registered = registerBinaryCallback(f);
305 """line 580, column 12 of dart:async/zone.dart: """, __x146 is Zone, 305 if (runGuarded) {
306 true))((implementation.function)( 306 return (arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2);
307 implZone, _parentDelegate(implZone), zone, specification, zoneValues)); 307 }
308 } 308 else {
309 } 309 return (arg1, arg2) => this.runBinary(registered, arg1, arg2);
310 abstract class _Zone implements Zone { 310 }
311 const _Zone(); 311 }
312 _ZoneFunction get _runUnary; 312 operator [](Object key) {
313 _ZoneFunction get _run; 313 var result = _map[key];
314 _ZoneFunction get _runBinary; 314 if (result != null || _map.containsKey(key)) return result;
315 _ZoneFunction get _registerCallback; 315 if (parent != null) {
316 _ZoneFunction get _registerUnaryCallback; 316 var value = parent[key];
317 _ZoneFunction get _registerBinaryCallback; 317 if (value != null) {
318 _ZoneFunction get _errorCallback; 318 _map[key] = value;
319 _ZoneFunction get _scheduleMicrotask; 319 }
320 _ZoneFunction get _createTimer; 320 return value;
321 _ZoneFunction get _createPeriodicTimer; 321 }
322 _ZoneFunction get _print; 322 assert (this == _ROOT_ZONE); return null;
323 _ZoneFunction get _fork; 323 }
324 _ZoneFunction get _handleUncaughtError; 324 dynamic handleUncaughtError(error, StackTrace stackTrace) {
325 _Zone get parent; 325 _ZoneFunction implementation = this._handleUncaughtError;
326 _ZoneDelegate get _delegate; 326 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
327 Map get _map; 327 return (implementation.function)(implementation.zone, parentDelegate, this, err or, stackTrace);
328 bool inSameErrorZone(Zone otherZone) { 328 }
329 return identical(this, otherZone) || 329 Zone fork({
330 identical(errorZone, otherZone.errorZone); 330 ZoneSpecification specification, Map zoneValues}
331 } 331 ) {
332 } 332 _ZoneFunction implementation = this._fork;
333 class _CustomZone extends _Zone { 333 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
334 _ZoneFunction _runUnary; 334 return ((__x147) => DDC$RT.cast(__x147, dynamic, Zone, "CastGeneral", """line 7 87, column 12 of dart:async/zone.dart: """, __x147 is Zone, true))((implementati on.function)(implementation.zone, parentDelegate, this, specification, zoneValue s));
335 _ZoneFunction _run; 335 }
336 _ZoneFunction _runBinary; 336 dynamic run(f()) {
337 _ZoneFunction _registerCallback; 337 _ZoneFunction implementation = this._run;
338 _ZoneFunction _registerUnaryCallback; 338 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
339 _ZoneFunction _registerBinaryCallback; 339 return (implementation.function)(implementation.zone, parentDelegate, this, f);
340 _ZoneFunction _errorCallback; 340 }
341 _ZoneFunction _scheduleMicrotask; 341 dynamic runUnary(f(arg), arg) {
342 _ZoneFunction _createTimer; 342 _ZoneFunction implementation = this._runUnary;
343 _ZoneFunction _createPeriodicTimer; 343 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
344 _ZoneFunction _print; 344 return (implementation.function)(implementation.zone, parentDelegate, this, f, arg);
345 _ZoneFunction _fork; 345 }
346 _ZoneFunction _handleUncaughtError; 346 dynamic runBinary(f(arg1, arg2), arg1, arg2) {
347 ZoneDelegate _delegateCache; 347 _ZoneFunction implementation = this._runBinary;
348 final _Zone parent; 348 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
349 final Map _map; 349 return (implementation.function)(implementation.zone, parentDelegate, this, f, arg1, arg2);
350 ZoneDelegate get _delegate { 350 }
351 if (_delegateCache != null) return _delegateCache; 351 ZoneCallback registerCallback(f()) {
352 _delegateCache = new _ZoneDelegate(this); 352 _ZoneFunction implementation = this._registerCallback;
353 return _delegateCache; 353 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
354 } 354 return ((__x148) => DDC$RT.cast(__x148, dynamic, __t134, "CastGeneral", """line 820, column 12 of dart:async/zone.dart: """, __x148 is __t134, false))((impleme ntation.function)(implementation.zone, parentDelegate, this, f));
355 _CustomZone(this.parent, ZoneSpecification specification, this._map) { 355 }
356 _run = (specification.run != null) 356 ZoneUnaryCallback registerUnaryCallback(f(arg)) {
357 ? new _ZoneFunction(this, specification.run) 357 _ZoneFunction implementation = this._registerUnaryCallback;
358 : parent._run; 358 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
359 _runUnary = (specification.runUnary != null) 359 return ((__x149) => DDC$RT.cast(__x149, dynamic, __t136, "CastGeneral", """line 828, column 12 of dart:async/zone.dart: """, __x149 is __t136, false))((impleme ntation.function)(implementation.zone, parentDelegate, this, f));
360 ? new _ZoneFunction(this, specification.runUnary) 360 }
361 : parent._runUnary; 361 ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) {
362 _runBinary = (specification.runBinary != null) 362 _ZoneFunction implementation = this._registerBinaryCallback;
363 ? new _ZoneFunction(this, specification.runBinary) 363 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
364 : parent._runBinary; 364 return ((__x150) => DDC$RT.cast(__x150, dynamic, __t139, "CastGeneral", """line 836, column 12 of dart:async/zone.dart: """, __x150 is __t139, false))((impleme ntation.function)(implementation.zone, parentDelegate, this, f));
365 _registerCallback = (specification.registerCallback != null) 365 }
366 ? new _ZoneFunction(this, specification.registerCallback) 366 AsyncError errorCallback(Object error, StackTrace stackTrace) {
367 : parent._registerCallback; 367 final _ZoneFunction implementation = this._errorCallback;
368 _registerUnaryCallback = (specification.registerUnaryCallback != null) 368 assert (implementation != null); final Zone implementationZone = implementation .zone;
369 ? new _ZoneFunction(this, specification.registerUnaryCallback) 369 if (identical(implementationZone, _ROOT_ZONE)) return null;
370 : parent._registerUnaryCallback; 370 final ZoneDelegate parentDelegate = _parentDelegate(DDC$RT.cast(implementationZ one, Zone, _Zone, "CastGeneral", """line 845, column 57 of dart:async/zone.dart: """, implementationZone is _Zone, true));
371 _registerBinaryCallback = (specification.registerBinaryCallback != null) 371 return ((__x151) => DDC$RT.cast(__x151, dynamic, AsyncError, "CastGeneral", """ line 846, column 12 of dart:async/zone.dart: """, __x151 is AsyncError, true))(( implementation.function)(implementationZone, parentDelegate, this, error, stackT race));
372 ? new _ZoneFunction(this, specification.registerBinaryCallback) 372 }
373 : parent._registerBinaryCallback; 373 void scheduleMicrotask(void f()) {
374 _errorCallback = (specification.errorCallback != null) 374 _ZoneFunction implementation = this._scheduleMicrotask;
375 ? new _ZoneFunction(this, specification.errorCallback) 375 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
376 : parent._errorCallback; 376 return (implementation.function)(implementation.zone, parentDelegate, this, f);
377 _scheduleMicrotask = (specification.scheduleMicrotask != null) 377 }
378 ? new _ZoneFunction(this, specification.scheduleMicrotask) 378 Timer createTimer(Duration duration, void f()) {
379 : parent._scheduleMicrotask; 379 _ZoneFunction implementation = this._createTimer;
380 _createTimer = (specification.createTimer != null) 380 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
381 ? new _ZoneFunction(this, specification.createTimer) 381 return ((__x152) => DDC$RT.cast(__x152, dynamic, Timer, "CastGeneral", """line 862, column 12 of dart:async/zone.dart: """, __x152 is Timer, true))((implementa tion.function)(implementation.zone, parentDelegate, this, duration, f));
382 : parent._createTimer; 382 }
383 _createPeriodicTimer = (specification.createPeriodicTimer != null) 383 Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
384 ? new _ZoneFunction(this, specification.createPeriodicTimer) 384 _ZoneFunction implementation = this._createPeriodicTimer;
385 : parent._createPeriodicTimer; 385 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
386 _print = (specification.print != null) 386 return ((__x153) => DDC$RT.cast(__x153, dynamic, Timer, "CastGeneral", """line 870, column 12 of dart:async/zone.dart: """, __x153 is Timer, true))((implementa tion.function)(implementation.zone, parentDelegate, this, duration, f));
387 ? new _ZoneFunction(this, specification.print) 387 }
388 : parent._print; 388 void print(String line) {
389 _fork = (specification.fork != null) 389 _ZoneFunction implementation = this._print;
390 ? new _ZoneFunction(this, specification.fork) 390 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate( implementation.zone);
391 : parent._fork; 391 return (implementation.function)(implementation.zone, parentDelegate, this, lin e);
392 _handleUncaughtError = (specification.handleUncaughtError != null) 392 }
393 ? new _ZoneFunction(this, specification.handleUncaughtError) 393 }
394 : parent._handleUncaughtError; 394 void _rootHandleUncaughtError(Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace) {
395 } 395 _schedulePriorityAsyncCallback(() {
396 Zone get errorZone => _handleUncaughtError.zone; 396 throw new _UncaughtAsyncError(error, stackTrace);
397 dynamic runGuarded(f()) { 397 }
398 try { 398 );
399 return run(f); 399 }
400 } catch (e, s) { 400 dynamic _rootRun(Zone self, ZoneDelegate parent, Zone zone, f()) {
401 return handleUncaughtError(e, s); 401 if (Zone._current == zone) return f();
402 } 402 Zone old = Zone._enter(zone);
403 } 403 try {
404 dynamic runUnaryGuarded(f(arg), arg) { 404 return f();
405 try { 405 }
406 return runUnary(f, arg); 406 finally {
407 } catch (e, s) { 407 Zone._leave(old);
408 return handleUncaughtError(e, s); 408 }
409 } 409 }
410 } 410 dynamic _rootRunUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg) {
411 dynamic runBinaryGuarded(f(arg1, arg2), arg1, arg2) { 411 if (Zone._current == zone) return f(arg);
412 try { 412 Zone old = Zone._enter(zone);
413 return runBinary(f, arg1, arg2); 413 try {
414 } catch (e, s) { 414 return f(arg);
415 return handleUncaughtError(e, s); 415 }
416 } 416 finally {
417 } 417 Zone._leave(old);
418 ZoneCallback bindCallback(f(), {bool runGuarded: true}) { 418 }
419 ZoneCallback registered = registerCallback(f); 419 }
420 if (runGuarded) { 420 dynamic _rootRunBinary(Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2) , arg1, arg2) {
421 return () => this.runGuarded(registered); 421 if (Zone._current == zone) return f(arg1, arg2);
422 } else { 422 Zone old = Zone._enter(zone);
423 return () => this.run(registered); 423 try {
424 } 424 return f(arg1, arg2);
425 } 425 }
426 ZoneUnaryCallback bindUnaryCallback(f(arg), {bool runGuarded: true}) { 426 finally {
427 ZoneUnaryCallback registered = registerUnaryCallback(f); 427 Zone._leave(old);
428 if (runGuarded) { 428 }
429 return (arg) => this.runUnaryGuarded(registered, arg); 429 }
430 } else { 430 ZoneCallback _rootRegisterCallback(Zone self, ZoneDelegate parent, Zone zone, f ()) {
431 return (arg) => this.runUnary(registered, arg); 431 return f;
432 } 432 }
433 } 433 ZoneUnaryCallback _rootRegisterUnaryCallback(Zone self, ZoneDelegate parent, Zo ne zone, f(arg)) {
434 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), 434 return f;
435 {bool runGuarded: true}) { 435 }
436 ZoneBinaryCallback registered = registerBinaryCallback(f); 436 ZoneBinaryCallback _rootRegisterBinaryCallback(Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)) {
437 if (runGuarded) { 437 return f;
438 return (arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2); 438 }
439 } else { 439 AsyncError _rootErrorCallback(Zone self, ZoneDelegate parent, Zone zone, Object error, StackTrace stackTrace) => null;
440 return (arg1, arg2) => this.runBinary(registered, arg1, arg2); 440 void _rootScheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) {
441 } 441 if (!identical(_ROOT_ZONE, zone)) {
442 } 442 bool hasErrorHandler = !_ROOT_ZONE.inSameErrorZone(zone);
443 operator [](Object key) { 443 f = zone.bindCallback(f, runGuarded: hasErrorHandler);
444 var result = _map[key]; 444 }
445 if (result != null || _map.containsKey(key)) return result; 445 _scheduleAsyncCallback(f);
446 if (parent != null) { 446 }
447 var value = parent[key]; 447 Timer _rootCreateTimer(Zone self, ZoneDelegate parent, Zone zone, Duration dura tion, void callback()) {
448 if (value != null) { 448 if (!identical(_ROOT_ZONE, zone)) {
449 _map[key] = value; 449 callback = zone.bindCallback(callback);
450 } 450 }
451 return value; 451 return Timer._createTimer(duration, callback);
452 } 452 }
453 assert(this == _ROOT_ZONE); 453 Timer _rootCreatePeriodicTimer(Zone self, ZoneDelegate parent, Zone zone, Durat ion duration, void callback(Timer timer)) {
454 return null; 454 if (!identical(_ROOT_ZONE, zone)) {
455 } 455 callback = zone.bindUnaryCallback(DDC$RT.wrap((void f(Timer __u154)) {
456 dynamic handleUncaughtError(error, StackTrace stackTrace) { 456 void c(Timer x0) => f(DDC$RT.cast(x0, dynamic, Timer, "CastParam", """line 962, column 39 of dart:async/zone.dart: """, x0 is Timer, true));
457 _ZoneFunction implementation = this._handleUncaughtError; 457 return f == null ? null : c;
458 assert(implementation != null); 458 }
459 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 459 , callback, __t155, __t136, "Wrap", """line 962, column 39 of dart:async/zone.da rt: """, callback is __t136));
460 return (implementation.function)( 460 }
461 implementation.zone, parentDelegate, this, error, stackTrace); 461 return Timer._createPeriodicTimer(duration, callback);
462 } 462 }
463 Zone fork({ZoneSpecification specification, Map zoneValues}) { 463 void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, String line) {
464 _ZoneFunction implementation = this._fork; 464 printToConsole(line);
465 assert(implementation != null); 465 }
466 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 466 void _printToZone(String line) {
467 return ((__x147) => DDC$RT.cast(__x147, dynamic, Zone, "CastGeneral", 467 Zone.current.print(line);
468 """line 787, column 12 of dart:async/zone.dart: """, __x147 is Zone, 468 }
469 true))((implementation.function)( 469 Zone _rootFork(Zone self, ZoneDelegate parent, Zone zone, ZoneSpecification spe cification, Map zoneValues) {
470 implementation.zone, parentDelegate, this, specification, zoneValues)); 470 printToZone = _printToZone;
471 } 471 if (specification == null) {
472 dynamic run(f()) { 472 specification = const ZoneSpecification();
473 _ZoneFunction implementation = this._run; 473 }
474 assert(implementation != null); 474 else if (specification is! _ZoneSpecification) {
475 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 475 throw new ArgumentError("ZoneSpecifications must be instantiated" " with the pro vided constructor.");
476 return (implementation.function)( 476 }
477 implementation.zone, parentDelegate, this, f); 477 Map valueMap;
478 } 478 if (zoneValues == null) {
479 dynamic runUnary(f(arg), arg) { 479 if (zone is _Zone) {
480 _ZoneFunction implementation = this._runUnary; 480 valueMap = zone._map;
481 assert(implementation != null); 481 }
482 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 482 else {
483 return (implementation.function)( 483 valueMap = new HashMap();
484 implementation.zone, parentDelegate, this, f, arg); 484 }
485 } 485 }
486 dynamic runBinary(f(arg1, arg2), arg1, arg2) { 486 else {
487 _ZoneFunction implementation = this._runBinary; 487 valueMap = new HashMap.from(zoneValues);
488 assert(implementation != null); 488 }
489 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 489 return new _CustomZone(zone, specification, valueMap);
490 return (implementation.function)( 490 }
491 implementation.zone, parentDelegate, this, f, arg1, arg2); 491 class _RootZoneSpecification implements ZoneSpecification {HandleUncaughtErrorH andler get handleUncaughtError => _rootHandleUncaughtError;
492 } 492 RunHandler get run => _rootRun;
493 ZoneCallback registerCallback(f()) { 493 RunUnaryHandler get runUnary => _rootRunUnary;
494 _ZoneFunction implementation = this._registerCallback; 494 RunBinaryHandler get runBinary => _rootRunBinary;
495 assert(implementation != null); 495 RegisterCallbackHandler get registerCallback => _rootRegisterCallback;
496 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 496 RegisterUnaryCallbackHandler get registerUnaryCallback => _rootRegisterUnaryCal lback;
497 return ((__x148) => DDC$RT.cast(__x148, dynamic, __t134, "CastGeneral", 497 RegisterBinaryCallbackHandler get registerBinaryCallback => _rootRegisterBinary Callback;
498 """line 820, column 12 of dart:async/zone.dart: """, 498 ErrorCallbackHandler get errorCallback => _rootErrorCallback;
499 __x148 is __t134, false))((implementation.function)( 499 ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask;
500 implementation.zone, parentDelegate, this, f)); 500 CreateTimerHandler get createTimer => _rootCreateTimer;
501 } 501 CreatePeriodicTimerHandler get createPeriodicTimer => _rootCreatePeriodicTimer;
502 ZoneUnaryCallback registerUnaryCallback(f(arg)) { 502 PrintHandler get print => _rootPrint;
503 _ZoneFunction implementation = this._registerUnaryCallback; 503 ForkHandler get fork => _rootFork;
504 assert(implementation != null); 504 }
505 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 505 class _RootZone extends _Zone {const _RootZone();
506 return ((__x149) => DDC$RT.cast(__x149, dynamic, __t136, "CastGeneral", 506 _ZoneFunction get _run => const _ZoneFunction(_ROOT_ZONE, _rootRun);
507 """line 828, column 12 of dart:async/zone.dart: """, 507 _ZoneFunction get _runUnary => const _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
508 __x149 is __t136, false))((implementation.function)( 508 _ZoneFunction get _runBinary => const _ZoneFunction(_ROOT_ZONE, _rootRunBinary) ;
509 implementation.zone, parentDelegate, this, f)); 509 _ZoneFunction get _registerCallback => const _ZoneFunction(_ROOT_ZONE, _rootReg isterCallback);
510 } 510 _ZoneFunction get _registerUnaryCallback => const _ZoneFunction(_ROOT_ZONE, _ro otRegisterUnaryCallback);
511 ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) { 511 _ZoneFunction get _registerBinaryCallback => const _ZoneFunction(_ROOT_ZONE, _r ootRegisterBinaryCallback);
512 _ZoneFunction implementation = this._registerBinaryCallback; 512 _ZoneFunction get _errorCallback => const _ZoneFunction(_ROOT_ZONE, _rootErrorC allback);
513 assert(implementation != null); 513 _ZoneFunction get _scheduleMicrotask => const _ZoneFunction(_ROOT_ZONE, _rootSc heduleMicrotask);
514 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 514 _ZoneFunction get _createTimer => const _ZoneFunction(_ROOT_ZONE, _rootCreateTi mer);
515 return ((__x150) => DDC$RT.cast(__x150, dynamic, __t139, "CastGeneral", 515 _ZoneFunction get _createPeriodicTimer => const _ZoneFunction(_ROOT_ZONE, _root CreatePeriodicTimer);
516 """line 836, column 12 of dart:async/zone.dart: """, 516 _ZoneFunction get _print => const _ZoneFunction(_ROOT_ZONE, _rootPrint);
517 __x150 is __t139, false))((implementation.function)( 517 _ZoneFunction get _fork => const _ZoneFunction(_ROOT_ZONE, _rootFork);
518 implementation.zone, parentDelegate, this, f)); 518 _ZoneFunction get _handleUncaughtError => const _ZoneFunction(_ROOT_ZONE, _root HandleUncaughtError);
519 } 519 _Zone get parent => null;
520 AsyncError errorCallback(Object error, StackTrace stackTrace) { 520 Map get _map => _rootMap;
521 final _ZoneFunction implementation = this._errorCallback; 521 static Map _rootMap = new HashMap();
522 assert(implementation != null); 522 static ZoneDelegate _rootDelegate;
523 final Zone implementationZone = implementation.zone; 523 ZoneDelegate get _delegate {
524 if (identical(implementationZone, _ROOT_ZONE)) return null; 524 if (_rootDelegate != null) return _rootDelegate;
525 final ZoneDelegate parentDelegate = _parentDelegate(DDC$RT.cast( 525 return _rootDelegate = new _ZoneDelegate(this);
526 implementationZone, Zone, _Zone, "CastGeneral", 526 }
527 """line 845, column 57 of dart:async/zone.dart: """, 527 Zone get errorZone => this;
528 implementationZone is _Zone, true)); 528 dynamic runGuarded(f()) {
529 return ((__x151) => DDC$RT.cast(__x151, dynamic, AsyncError, "CastGeneral", 529 try {
530 """line 846, column 12 of dart:async/zone.dart: """, 530 if (identical(_ROOT_ZONE, Zone._current)) {
531 __x151 is AsyncError, true))((implementation.function)( 531 return f();
532 implementationZone, parentDelegate, this, error, stackTrace)); 532 }
533 } 533 return _rootRun(null, null, this, f);
534 void scheduleMicrotask(void f()) { 534 }
535 _ZoneFunction implementation = this._scheduleMicrotask; 535 catch (e, s) {
536 assert(implementation != null); 536 return handleUncaughtError(e, s);
537 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 537 }
538 return (implementation.function)( 538 }
539 implementation.zone, parentDelegate, this, f); 539 dynamic runUnaryGuarded(f(arg), arg) {
540 } 540 try {
541 Timer createTimer(Duration duration, void f()) { 541 if (identical(_ROOT_ZONE, Zone._current)) {
542 _ZoneFunction implementation = this._createTimer; 542 return f(arg);
543 assert(implementation != null); 543 }
544 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 544 return _rootRunUnary(null, null, this, f, arg);
545 return ((__x152) => DDC$RT.cast(__x152, dynamic, Timer, "CastGeneral", 545 }
546 """line 862, column 12 of dart:async/zone.dart: """, 546 catch (e, s) {
547 __x152 is Timer, true))((implementation.function)( 547 return handleUncaughtError(e, s);
548 implementation.zone, parentDelegate, this, duration, f)); 548 }
549 } 549 }
550 Timer createPeriodicTimer(Duration duration, void f(Timer timer)) { 550 dynamic runBinaryGuarded(f(arg1, arg2), arg1, arg2) {
551 _ZoneFunction implementation = this._createPeriodicTimer; 551 try {
552 assert(implementation != null); 552 if (identical(_ROOT_ZONE, Zone._current)) {
553 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 553 return f(arg1, arg2);
554 return ((__x153) => DDC$RT.cast(__x153, dynamic, Timer, "CastGeneral", 554 }
555 """line 870, column 12 of dart:async/zone.dart: """, 555 return _rootRunBinary(null, null, this, f, arg1, arg2);
556 __x153 is Timer, true))((implementation.function)( 556 }
557 implementation.zone, parentDelegate, this, duration, f)); 557 catch (e, s) {
558 } 558 return handleUncaughtError(e, s);
559 void print(String line) { 559 }
560 _ZoneFunction implementation = this._print; 560 }
561 assert(implementation != null); 561 ZoneCallback bindCallback(f(), {
562 ZoneDelegate parentDelegate = _parentDelegate(implementation.zone); 562 bool runGuarded : true}
563 return (implementation.function)( 563 ) {
564 implementation.zone, parentDelegate, this, line); 564 if (runGuarded) {
565 } 565 return () => this.runGuarded(f);
566 } 566 }
567 void _rootHandleUncaughtError( 567 else {
568 Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace) { 568 return () => this.run(f);
569 _schedulePriorityAsyncCallback(() { 569 }
570 throw new _UncaughtAsyncError(error, stackTrace); 570 }
571 }); 571 ZoneUnaryCallback bindUnaryCallback(f(arg), {
572 } 572 bool runGuarded : true}
573 dynamic _rootRun(Zone self, ZoneDelegate parent, Zone zone, f()) { 573 ) {
574 if (Zone._current == zone) return f(); 574 if (runGuarded) {
575 Zone old = Zone._enter(zone); 575 return (arg) => this.runUnaryGuarded(f, arg);
576 try { 576 }
577 return f(); 577 else {
578 } finally { 578 return (arg) => this.runUnary(f, arg);
579 Zone._leave(old); 579 }
580 } 580 }
581 } 581 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), {
582 dynamic _rootRunUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg) { 582 bool runGuarded : true}
583 if (Zone._current == zone) return f(arg); 583 ) {
584 Zone old = Zone._enter(zone); 584 if (runGuarded) {
585 try { 585 return (arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2);
586 return f(arg); 586 }
587 } finally { 587 else {
588 Zone._leave(old); 588 return (arg1, arg2) => this.runBinary(f, arg1, arg2);
589 } 589 }
590 } 590 }
591 dynamic _rootRunBinary( 591 operator [](Object key) => null;
592 Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2), arg1, arg2) { 592 dynamic handleUncaughtError(error, StackTrace stackTrace) {
593 if (Zone._current == zone) return f(arg1, arg2); 593 return _rootHandleUncaughtError(null, null, this, error, stackTrace);
594 Zone old = Zone._enter(zone); 594 }
595 try { 595 Zone fork({
596 return f(arg1, arg2); 596 ZoneSpecification specification, Map zoneValues}
597 } finally { 597 ) {
598 Zone._leave(old); 598 return _rootFork(null, null, this, specification, zoneValues);
599 } 599 }
600 } 600 dynamic run(f()) {
601 ZoneCallback _rootRegisterCallback( 601 if (identical(Zone._current, _ROOT_ZONE)) return f();
602 Zone self, ZoneDelegate parent, Zone zone, f()) { 602 return _rootRun(null, null, this, f);
603 return f; 603 }
604 } 604 dynamic runUnary(f(arg), arg) {
605 ZoneUnaryCallback _rootRegisterUnaryCallback( 605 if (identical(Zone._current, _ROOT_ZONE)) return f(arg);
606 Zone self, ZoneDelegate parent, Zone zone, f(arg)) { 606 return _rootRunUnary(null, null, this, f, arg);
607 return f; 607 }
608 } 608 dynamic runBinary(f(arg1, arg2), arg1, arg2) {
609 ZoneBinaryCallback _rootRegisterBinaryCallback( 609 if (identical(Zone._current, _ROOT_ZONE)) return f(arg1, arg2);
610 Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)) { 610 return _rootRunBinary(null, null, this, f, arg1, arg2);
611 return f; 611 }
612 } 612 ZoneCallback registerCallback(f()) => f;
613 AsyncError _rootErrorCallback(Zone self, ZoneDelegate parent, Zone zone, 613 ZoneUnaryCallback registerUnaryCallback(f(arg)) => f;
614 Object error, StackTrace stackTrace) => null; 614 ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) => f;
615 void _rootScheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) { 615 AsyncError errorCallback(Object error, StackTrace stackTrace) => null;
616 if (!identical(_ROOT_ZONE, zone)) { 616 void scheduleMicrotask(void f()) {
617 bool hasErrorHandler = !_ROOT_ZONE.inSameErrorZone(zone); 617 _rootScheduleMicrotask(null, null, this, f);
618 f = zone.bindCallback(f, runGuarded: hasErrorHandler); 618 }
619 } 619 Timer createTimer(Duration duration, void f()) {
620 _scheduleAsyncCallback(f); 620 return Timer._createTimer(duration, f);
621 } 621 }
622 Timer _rootCreateTimer(Zone self, ZoneDelegate parent, Zone zone, 622 Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
623 Duration duration, void callback()) { 623 return Timer._createPeriodicTimer(duration, f);
624 if (!identical(_ROOT_ZONE, zone)) { 624 }
625 callback = zone.bindCallback(callback); 625 void print(String line) {
626 } 626 printToConsole(line);
627 return Timer._createTimer(duration, callback); 627 }
628 } 628 }
629 Timer _rootCreatePeriodicTimer(Zone self, ZoneDelegate parent, Zone zone, 629 const _ROOT_ZONE = const _RootZone();
630 Duration duration, void callback(Timer timer)) { 630 dynamic runZoned(body(), {
631 if (!identical(_ROOT_ZONE, zone)) { 631 Map zoneValues, ZoneSpecification zoneSpecification, Function onError}
632 callback = zone.bindUnaryCallback(DDC$RT.wrap((void f(Timer __u154)) { 632 ) {
633 void c(Timer x0) => f(DDC$RT.cast(x0, dynamic, Timer, "CastParam", 633 HandleUncaughtErrorHandler errorHandler;
634 """line 962, column 39 of dart:async/zone.dart: """, x0 is Timer, 634 if (onError != null) {
635 true)); 635 errorHandler = (Zone self, ZoneDelegate parent, Zone zone, error, StackTrace sta ckTrace) {
636 return f == null ? null : c; 636 try {
637 }, callback, __t155, __t136, "Wrap", 637 if (onError is ZoneBinaryCallback) {
638 """line 962, column 39 of dart:async/zone.dart: """, 638 return self.parent.runBinary(onError, error, stackTrace);
639 callback is __t136)); 639 }
640 } 640 return self.parent.runUnary(DDC$RT.cast(onError, Function, __t136, "CastGeneral ", """line 1228, column 37 of dart:async/zone.dart: """, onError is __t136, fals e), error);
641 return Timer._createPeriodicTimer(duration, callback); 641 }
642 } 642 catch (e, s) {
643 void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, String line) { 643 if (identical(e, error)) {
644 printToConsole(line); 644 return parent.handleUncaughtError(zone, error, stackTrace);
645 } 645 }
646 void _printToZone(String line) { 646 else {
647 Zone.current.print(line); 647 return parent.handleUncaughtError(zone, e, s);
648 } 648 }
649 Zone _rootFork(Zone self, ZoneDelegate parent, Zone zone, 649 }
650 ZoneSpecification specification, Map zoneValues) { 650 }
651 printToZone = _printToZone; 651 ;
652 if (specification == null) { 652 }
653 specification = const ZoneSpecification(); 653 if (zoneSpecification == null) {
654 } else if (specification is! _ZoneSpecification) { 654 zoneSpecification = new ZoneSpecification(handleUncaughtError: errorHandler);
655 throw new ArgumentError( 655 }
656 "ZoneSpecifications must be instantiated" " with the provided constructo r."); 656 else if (errorHandler != null) {
657 } 657 zoneSpecification = new ZoneSpecification.from(zoneSpecification, handleUncaught Error: errorHandler);
658 Map valueMap; 658 }
659 if (zoneValues == null) { 659 Zone zone = Zone.current.fork(specification: zoneSpecification, zoneValues: zon eValues);
660 if (zone is _Zone) { 660 if (onError != null) {
661 valueMap = zone._map; 661 return zone.runGuarded(body);
662 } else { 662 }
663 valueMap = new HashMap(); 663 else {
664 } 664 return zone.run(body);
665 } else { 665 }
666 valueMap = new HashMap.from(zoneValues); 666 }
667 } 667 typedef dynamic __t134();
668 return new _CustomZone(zone, specification, valueMap); 668 typedef dynamic __t136(dynamic __u137);
669 } 669 typedef dynamic __t139(dynamic __u140, dynamic __u141);
670 class _RootZoneSpecification implements ZoneSpecification { 670 typedef void __t155(Timer __u156);
671 HandleUncaughtErrorHandler get handleUncaughtError =>
672 _rootHandleUncaughtError;
673 RunHandler get run => _rootRun;
674 RunUnaryHandler get runUnary => _rootRunUnary;
675 RunBinaryHandler get runBinary => _rootRunBinary;
676 RegisterCallbackHandler get registerCallback => _rootRegisterCallback;
677 RegisterUnaryCallbackHandler get registerUnaryCallback =>
678 _rootRegisterUnaryCallback;
679 RegisterBinaryCallbackHandler get registerBinaryCallback =>
680 _rootRegisterBinaryCallback;
681 ErrorCallbackHandler get errorCallback => _rootErrorCallback;
682 ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask;
683 CreateTimerHandler get createTimer => _rootCreateTimer;
684 CreatePeriodicTimerHandler get createPeriodicTimer =>
685 _rootCreatePeriodicTimer;
686 PrintHandler get print => _rootPrint;
687 ForkHandler get fork => _rootFork;
688 }
689 class _RootZone extends _Zone {
690 const _RootZone();
691 _ZoneFunction get _run => const _ZoneFunction(_ROOT_ZONE, _rootRun);
692 _ZoneFunction get _runUnary => const _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
693 _ZoneFunction get _runBinary =>
694 const _ZoneFunction(_ROOT_ZONE, _rootRunBinary);
695 _ZoneFunction get _registerCallback =>
696 const _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback);
697 _ZoneFunction get _registerUnaryCallback =>
698 const _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback);
699 _ZoneFunction get _registerBinaryCallback =>
700 const _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback);
701 _ZoneFunction get _errorCallback =>
702 const _ZoneFunction(_ROOT_ZONE, _rootErrorCallback);
703 _ZoneFunction get _scheduleMicrotask =>
704 const _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask);
705 _ZoneFunction get _createTimer =>
706 const _ZoneFunction(_ROOT_ZONE, _rootCreateTimer);
707 _ZoneFunction get _createPeriodicTimer =>
708 const _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer);
709 _ZoneFunction get _print => const _ZoneFunction(_ROOT_ZONE, _rootPrint);
710 _ZoneFunction get _fork => const _ZoneFunction(_ROOT_ZONE, _rootFork);
711 _ZoneFunction get _handleUncaughtError =>
712 const _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError);
713 _Zone get parent => null;
714 Map get _map => _rootMap;
715 static Map _rootMap = new HashMap();
716 static ZoneDelegate _rootDelegate;
717 ZoneDelegate get _delegate {
718 if (_rootDelegate != null) return _rootDelegate;
719 return _rootDelegate = new _ZoneDelegate(this);
720 }
721 Zone get errorZone => this;
722 dynamic runGuarded(f()) {
723 try {
724 if (identical(_ROOT_ZONE, Zone._current)) {
725 return f();
726 }
727 return _rootRun(null, null, this, f);
728 } catch (e, s) {
729 return handleUncaughtError(e, s);
730 }
731 }
732 dynamic runUnaryGuarded(f(arg), arg) {
733 try {
734 if (identical(_ROOT_ZONE, Zone._current)) {
735 return f(arg);
736 }
737 return _rootRunUnary(null, null, this, f, arg);
738 } catch (e, s) {
739 return handleUncaughtError(e, s);
740 }
741 }
742 dynamic runBinaryGuarded(f(arg1, arg2), arg1, arg2) {
743 try {
744 if (identical(_ROOT_ZONE, Zone._current)) {
745 return f(arg1, arg2);
746 }
747 return _rootRunBinary(null, null, this, f, arg1, arg2);
748 } catch (e, s) {
749 return handleUncaughtError(e, s);
750 }
751 }
752 ZoneCallback bindCallback(f(), {bool runGuarded: true}) {
753 if (runGuarded) {
754 return () => this.runGuarded(f);
755 } else {
756 return () => this.run(f);
757 }
758 }
759 ZoneUnaryCallback bindUnaryCallback(f(arg), {bool runGuarded: true}) {
760 if (runGuarded) {
761 return (arg) => this.runUnaryGuarded(f, arg);
762 } else {
763 return (arg) => this.runUnary(f, arg);
764 }
765 }
766 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2),
767 {bool runGuarded: true}) {
768 if (runGuarded) {
769 return (arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2);
770 } else {
771 return (arg1, arg2) => this.runBinary(f, arg1, arg2);
772 }
773 }
774 operator [](Object key) => null;
775 dynamic handleUncaughtError(error, StackTrace stackTrace) {
776 return _rootHandleUncaughtError(null, null, this, error, stackTrace);
777 }
778 Zone fork({ZoneSpecification specification, Map zoneValues}) {
779 return _rootFork(null, null, this, specification, zoneValues);
780 }
781 dynamic run(f()) {
782 if (identical(Zone._current, _ROOT_ZONE)) return f();
783 return _rootRun(null, null, this, f);
784 }
785 dynamic runUnary(f(arg), arg) {
786 if (identical(Zone._current, _ROOT_ZONE)) return f(arg);
787 return _rootRunUnary(null, null, this, f, arg);
788 }
789 dynamic runBinary(f(arg1, arg2), arg1, arg2) {
790 if (identical(Zone._current, _ROOT_ZONE)) return f(arg1, arg2);
791 return _rootRunBinary(null, null, this, f, arg1, arg2);
792 }
793 ZoneCallback registerCallback(f()) => f;
794 ZoneUnaryCallback registerUnaryCallback(f(arg)) => f;
795 ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) => f;
796 AsyncError errorCallback(Object error, StackTrace stackTrace) => null;
797 void scheduleMicrotask(void f()) {
798 _rootScheduleMicrotask(null, null, this, f);
799 }
800 Timer createTimer(Duration duration, void f()) {
801 return Timer._createTimer(duration, f);
802 }
803 Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
804 return Timer._createPeriodicTimer(duration, f);
805 }
806 void print(String line) {
807 printToConsole(line);
808 }
809 }
810 const _ROOT_ZONE = const _RootZone();
811 dynamic runZoned(body(),
812 {Map zoneValues, ZoneSpecification zoneSpecification, Function onError}) {
813 HandleUncaughtErrorHandler errorHandler;
814 if (onError != null) {
815 errorHandler = (Zone self, ZoneDelegate parent, Zone zone, error,
816 StackTrace stackTrace) {
817 try {
818 if (onError is ZoneBinaryCallback) {
819 return self.parent.runBinary(onError, error, stackTrace);
820 }
821 return self.parent.runUnary(DDC$RT.cast(onError, Function, __t136,
822 "CastGeneral", """line 1228, column 37 of dart:async/zone.dart: """,
823 onError is __t136, false), error);
824 } catch (e, s) {
825 if (identical(e, error)) {
826 return parent.handleUncaughtError(zone, error, stackTrace);
827 } else {
828 return parent.handleUncaughtError(zone, e, s);
829 }
830 }
831 };
832 }
833 if (zoneSpecification == null) {
834 zoneSpecification =
835 new ZoneSpecification(handleUncaughtError: errorHandler);
836 } else if (errorHandler != null) {
837 zoneSpecification = new ZoneSpecification.from(zoneSpecification,
838 handleUncaughtError: errorHandler);
839 }
840 Zone zone = Zone.current.fork(
841 specification: zoneSpecification, zoneValues: zoneValues);
842 if (onError != null) {
843 return zone.runGuarded(body);
844 } else {
845 return zone.run(body);
846 }
847 }
848 typedef dynamic __t134();
849 typedef dynamic __t136(dynamic __u137);
850 typedef dynamic __t139(dynamic __u140, dynamic __u141);
851 typedef void __t155(Timer __u156);
OLDNEW
« test/dart_codegen/expect/_internal/iterable.dart ('K') | « test/dart_codegen/expect/async/timer.dart ('k') | test/dart_codegen/expect/collection/collection » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698