| OLD | NEW |
|---|
| (Empty) |
| 1 part of dart.async; | |
| 2 typedef dynamic ZoneCallback(); | |
| 3 typedef dynamic ZoneUnaryCallback(arg); | |
| 4 typedef dynamic ZoneBinaryCallback(arg1, arg2); | |
| 5 typedef dynamic HandleUncaughtErrorHandler(Zone self, ZoneDelegate parent, Zone
zone, error, StackTrace stackTrace); | |
| 6 typedef dynamic RunHandler(Zone self, ZoneDelegate parent, Zone zone, f()); | |
| 7 typedef dynamic RunUnaryHandler(Zone self, ZoneDelegate parent, Zone zone, f(ar
g), arg); | |
| 8 typedef dynamic RunBinaryHandler(Zone self, ZoneDelegate parent, Zone zone, f(a
rg1, arg2), arg1, arg2); | |
| 9 typedef ZoneCallback RegisterCallbackHandler(Zone self, ZoneDelegate parent, Zo
ne zone, f()); | |
| 10 typedef ZoneUnaryCallback RegisterUnaryCallbackHandler(Zone self, ZoneDelegate
parent, Zone zone, f(arg)); | |
| 11 typedef ZoneBinaryCallback RegisterBinaryCallbackHandler(Zone self, ZoneDelegat
e parent, Zone zone, f(arg1, arg2)); | |
| 12 typedef AsyncError ErrorCallbackHandler(Zone self, ZoneDelegate parent, Zone zo
ne, Object error, StackTrace stackTrace); | |
| 13 typedef void ScheduleMicrotaskHandler(Zone self, ZoneDelegate parent, Zone zone
, f()); | |
| 14 typedef Timer CreateTimerHandler(Zone self, ZoneDelegate parent, Zone zone, Dur
ation duration, void f()); | |
| 15 typedef Timer CreatePeriodicTimerHandler(Zone self, ZoneDelegate parent, Zone z
one, Duration period, void f(Timer timer)); | |
| 16 typedef void PrintHandler(Zone self, ZoneDelegate parent, Zone zone, String lin
e); | |
| 17 typedef Zone ForkHandler(Zone self, ZoneDelegate parent, Zone zone, ZoneSpecifi
cation specification, Map zoneValues); | |
| 18 class AsyncError implements Error {final error; | |
| 19 final StackTrace stackTrace; | |
| 20 AsyncError(this.error, this.stackTrace); | |
| 21 String toString() => error.toString(); | |
| 22 } | |
| 23 class _ZoneFunction {final _Zone zone; | |
| 24 final Function function; | |
| 25 const _ZoneFunction(this.zone, this.function); | |
| 26 } | |
| 27 abstract class ZoneSpecification {const factory ZoneSpecification({ | |
| 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 ) = _ZoneSpecification; | |
| 30 factory ZoneSpecification.from(ZoneSpecification other, { | |
| 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 ) { | |
| 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 } | |
| 35 HandleUncaughtErrorHandler get handleUncaughtError; | |
| 36 RunHandler get run; | |
| 37 RunUnaryHandler get runUnary; | |
| 38 RunBinaryHandler get runBinary; | |
| 39 RegisterCallbackHandler get registerCallback; | |
| 40 RegisterUnaryCallbackHandler get registerUnaryCallback; | |
| 41 RegisterBinaryCallbackHandler get registerBinaryCallback; | |
| 42 ErrorCallbackHandler get errorCallback; | |
| 43 ScheduleMicrotaskHandler get scheduleMicrotask; | |
| 44 CreateTimerHandler get createTimer; | |
| 45 CreatePeriodicTimerHandler get createPeriodicTimer; | |
| 46 PrintHandler get print; | |
| 47 ForkHandler get fork; | |
| 48 } | |
| 49 class _ZoneSpecification implements ZoneSpecification {const _ZoneSpecification
({ | |
| 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 ); | |
| 52 final handleUncaughtError; | |
| 53 final run; | |
| 54 final runUnary; | |
| 55 final runBinary; | |
| 56 final registerCallback; | |
| 57 final registerUnaryCallback; | |
| 58 final registerBinaryCallback; | |
| 59 final errorCallback; | |
| 60 final scheduleMicrotask; | |
| 61 final createTimer; | |
| 62 final createPeriodicTimer; | |
| 63 final print; | |
| 64 final fork; | |
| 65 } | |
| 66 abstract class ZoneDelegate {dynamic handleUncaughtError(Zone zone, error, Stac
kTrace stackTrace); | |
| 67 dynamic run(Zone zone, f()); | |
| 68 dynamic runUnary(Zone zone, f(arg), arg); | |
| 69 dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2); | |
| 70 ZoneCallback registerCallback(Zone zone, f()); | |
| 71 ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg)); | |
| 72 ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2)); | |
| 73 AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace); | |
| 74 void scheduleMicrotask(Zone zone, f()); | |
| 75 Timer createTimer(Zone zone, Duration duration, void f()); | |
| 76 Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)); | |
| 77 void print(Zone zone, String line); | |
| 78 Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues); | |
| 79 } | |
| 80 abstract class Zone {Zone._(); | |
| 81 static const Zone ROOT = _ROOT_ZONE; | |
| 82 static Zone _current = _ROOT_ZONE; | |
| 83 static Zone get current => _current; | |
| 84 dynamic handleUncaughtError(error, StackTrace stackTrace); | |
| 85 Zone get parent; | |
| 86 Zone get errorZone; | |
| 87 bool inSameErrorZone(Zone otherZone); | |
| 88 Zone fork({ | |
| 89 ZoneSpecification specification, Map zoneValues} | |
| 90 ); | |
| 91 dynamic run(f()); | |
| 92 dynamic runUnary(f(arg), var arg); | |
| 93 dynamic runBinary(f(arg1, arg2), var arg1, var arg2); | |
| 94 dynamic runGuarded(f()); | |
| 95 dynamic runUnaryGuarded(f(arg), var arg); | |
| 96 dynamic runBinaryGuarded(f(arg1, arg2), var arg1, var arg2); | |
| 97 ZoneCallback registerCallback(callback()); | |
| 98 ZoneUnaryCallback registerUnaryCallback(callback(arg)); | |
| 99 ZoneBinaryCallback registerBinaryCallback(callback(arg1, arg2)); | |
| 100 ZoneCallback bindCallback(f(), { | |
| 101 bool runGuarded : true} | |
| 102 ); | |
| 103 ZoneUnaryCallback bindUnaryCallback(f(arg), { | |
| 104 bool runGuarded : true} | |
| 105 ); | |
| 106 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), { | |
| 107 bool runGuarded : true} | |
| 108 ); | |
| 109 AsyncError errorCallback(Object error, StackTrace stackTrace); | |
| 110 void scheduleMicrotask(void f()); | |
| 111 Timer createTimer(Duration duration, void callback()); | |
| 112 Timer createPeriodicTimer(Duration period, void callback(Timer timer)); | |
| 113 void print(String line); | |
| 114 static Zone _enter(Zone zone) { | |
| 115 assert (zone != null); assert (!identical(zone, _current)); Zone previous = _cur
rent; | |
| 116 _current = zone; | |
| 117 return previous; | |
| 118 } | |
| 119 static void _leave(Zone previous) { | |
| 120 assert (previous != null); Zone._current = previous; | |
| 121 } | |
| 122 operator [](Object key); | |
| 123 } | |
| 124 ZoneDelegate _parentDelegate(_Zone zone) { | |
| 125 if (zone.parent == null) return null; | |
| 126 return zone.parent._delegate; | |
| 127 } | |
| 128 class _ZoneDelegate implements ZoneDelegate {final _Zone _delegationTarget; | |
| 129 _ZoneDelegate(this._delegationTarget); | |
| 130 dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace) { | |
| 131 _ZoneFunction implementation = _delegationTarget._handleUncaughtError; | |
| 132 _Zone implZone = implementation.zone; | |
| 133 return (implementation.function)(implZone, _parentDelegate(implZone), zone, err
or, stackTrace); | |
| 134 } | |
| 135 dynamic run(Zone zone, f()) { | |
| 136 _ZoneFunction implementation = _delegationTarget._run; | |
| 137 _Zone implZone = implementation.zone; | |
| 138 return (implementation.function)(implZone, _parentDelegate(implZone), zone, f); | |
| 139 } | |
| 140 dynamic runUnary(Zone zone, f(arg), arg) { | |
| 141 _ZoneFunction implementation = _delegationTarget._runUnary; | |
| 142 _Zone implZone = implementation.zone; | |
| 143 return (implementation.function)(implZone, _parentDelegate(implZone), zone, f,
arg); | |
| 144 } | |
| 145 dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2) { | |
| 146 _ZoneFunction implementation = _delegationTarget._runBinary; | |
| 147 _Zone implZone = implementation.zone; | |
| 148 return (implementation.function)(implZone, _parentDelegate(implZone), zone, f,
arg1, arg2); | |
| 149 } | |
| 150 ZoneCallback registerCallback(Zone zone, f()) { | |
| 151 _ZoneFunction implementation = _delegationTarget._registerCallback; | |
| 152 _Zone implZone = implementation.zone; | |
| 153 return ((__x79) => DEVC$RT.cast(__x79, dynamic, ZoneCallback, "DynamicCast", ""
"line 522, column 12 of dart:async/zone.dart: """, __x79 is ZoneCallback, true))
((implementation.function)(implZone, _parentDelegate(implZone), zone, f)); | |
| 154 } | |
| 155 ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg)) { | |
| 156 _ZoneFunction implementation = _delegationTarget._registerUnaryCallback; | |
| 157 _Zone implZone = implementation.zone; | |
| 158 return ((__x80) => DEVC$RT.cast(__x80, dynamic, ZoneUnaryCallback, "DynamicCast
", """line 529, column 12 of dart:async/zone.dart: """, __x80 is ZoneUnaryCallba
ck, true))((implementation.function)(implZone, _parentDelegate(implZone), zone,
f)); | |
| 159 } | |
| 160 ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2)) { | |
| 161 _ZoneFunction implementation = _delegationTarget._registerBinaryCallback; | |
| 162 _Zone implZone = implementation.zone; | |
| 163 return ((__x81) => DEVC$RT.cast(__x81, dynamic, ZoneBinaryCallback, "DynamicCas
t", """line 536, column 12 of dart:async/zone.dart: """, __x81 is ZoneBinaryCall
back, true))((implementation.function)(implZone, _parentDelegate(implZone), zone
, f)); | |
| 164 } | |
| 165 AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace) { | |
| 166 _ZoneFunction implementation = _delegationTarget._errorCallback; | |
| 167 _Zone implZone = implementation.zone; | |
| 168 if (identical(implZone, _ROOT_ZONE)) return null; | |
| 169 return ((__x82) => DEVC$RT.cast(__x82, dynamic, AsyncError, "DynamicCast", """l
ine 544, column 12 of dart:async/zone.dart: """, __x82 is AsyncError, true))((im
plementation.function)(implZone, _parentDelegate(implZone), zone, error, stackTr
ace)); | |
| 170 } | |
| 171 void scheduleMicrotask(Zone zone, f()) { | |
| 172 _ZoneFunction implementation = _delegationTarget._scheduleMicrotask; | |
| 173 _Zone implZone = implementation.zone; | |
| 174 (implementation.function)(implZone, _parentDelegate(implZone), zone, f); | |
| 175 } | |
| 176 Timer createTimer(Zone zone, Duration duration, void f()) { | |
| 177 _ZoneFunction implementation = _delegationTarget._createTimer; | |
| 178 _Zone implZone = implementation.zone; | |
| 179 return ((__x83) => DEVC$RT.cast(__x83, dynamic, Timer, "DynamicCast", """line 5
58, column 12 of dart:async/zone.dart: """, __x83 is Timer, true))((implementati
on.function)(implZone, _parentDelegate(implZone), zone, duration, f)); | |
| 180 } | |
| 181 Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)) { | |
| 182 _ZoneFunction implementation = _delegationTarget._createPeriodicTimer; | |
| 183 _Zone implZone = implementation.zone; | |
| 184 return ((__x84) => DEVC$RT.cast(__x84, dynamic, Timer, "DynamicCast", """line 5
65, column 12 of dart:async/zone.dart: """, __x84 is Timer, true))((implementati
on.function)(implZone, _parentDelegate(implZone), zone, period, f)); | |
| 185 } | |
| 186 void print(Zone zone, String line) { | |
| 187 _ZoneFunction implementation = _delegationTarget._print; | |
| 188 _Zone implZone = implementation.zone; | |
| 189 (implementation.function)(implZone, _parentDelegate(implZone), zone, line); | |
| 190 } | |
| 191 Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues) { | |
| 192 _ZoneFunction implementation = _delegationTarget._fork; | |
| 193 _Zone implZone = implementation.zone; | |
| 194 return ((__x85) => DEVC$RT.cast(__x85, dynamic, Zone, "DynamicCast", """line 58
0, column 12 of dart:async/zone.dart: """, __x85 is Zone, true))((implementation
.function)(implZone, _parentDelegate(implZone), zone, specification, zoneValues)
); | |
| 195 } | |
| 196 } | |
| 197 abstract class _Zone implements Zone {const _Zone(); | |
| 198 _ZoneFunction get _runUnary; | |
| 199 _ZoneFunction get _run; | |
| 200 _ZoneFunction get _runBinary; | |
| 201 _ZoneFunction get _registerCallback; | |
| 202 _ZoneFunction get _registerUnaryCallback; | |
| 203 _ZoneFunction get _registerBinaryCallback; | |
| 204 _ZoneFunction get _errorCallback; | |
| 205 _ZoneFunction get _scheduleMicrotask; | |
| 206 _ZoneFunction get _createTimer; | |
| 207 _ZoneFunction get _createPeriodicTimer; | |
| 208 _ZoneFunction get _print; | |
| 209 _ZoneFunction get _fork; | |
| 210 _ZoneFunction get _handleUncaughtError; | |
| 211 _Zone get parent; | |
| 212 ZoneDelegate get _delegate; | |
| 213 Map get _map; | |
| 214 bool inSameErrorZone(Zone otherZone) { | |
| 215 return identical(this, otherZone) || identical(errorZone, otherZone.errorZone); | |
| 216 } | |
| 217 } | |
| 218 class _CustomZone extends _Zone {_ZoneFunction _runUnary; | |
| 219 _ZoneFunction _run; | |
| 220 _ZoneFunction _runBinary; | |
| 221 _ZoneFunction _registerCallback; | |
| 222 _ZoneFunction _registerUnaryCallback; | |
| 223 _ZoneFunction _registerBinaryCallback; | |
| 224 _ZoneFunction _errorCallback; | |
| 225 _ZoneFunction _scheduleMicrotask; | |
| 226 _ZoneFunction _createTimer; | |
| 227 _ZoneFunction _createPeriodicTimer; | |
| 228 _ZoneFunction _print; | |
| 229 _ZoneFunction _fork; | |
| 230 _ZoneFunction _handleUncaughtError; | |
| 231 ZoneDelegate _delegateCache; | |
| 232 final _Zone parent; | |
| 233 final Map _map; | |
| 234 ZoneDelegate get _delegate { | |
| 235 if (_delegateCache != null) return _delegateCache; | |
| 236 _delegateCache = new _ZoneDelegate(this); | |
| 237 return _delegateCache; | |
| 238 } | |
| 239 _CustomZone(this.parent, ZoneSpecification specification, this._map) { | |
| 240 _run = (specification.run != null) ? new _ZoneFunction(this, specification.run)
: parent._run; | |
| 241 _runUnary = (specification.runUnary != null) ? new _ZoneFunction(this, specific
ation.runUnary) : parent._runUnary; | |
| 242 _runBinary = (specification.runBinary != null) ? new _ZoneFunction(this, specif
ication.runBinary) : parent._runBinary; | |
| 243 _registerCallback = (specification.registerCallback != null) ? new _ZoneFunctio
n(this, specification.registerCallback) : parent._registerCallback; | |
| 244 _registerUnaryCallback = (specification.registerUnaryCallback != null) ? new _Z
oneFunction(this, specification.registerUnaryCallback) : parent._registerUnaryCa
llback; | |
| 245 _registerBinaryCallback = (specification.registerBinaryCallback != null) ? new
_ZoneFunction(this, specification.registerBinaryCallback) : parent._registerBina
ryCallback; | |
| 246 _errorCallback = (specification.errorCallback != null) ? new _ZoneFunction(this
, specification.errorCallback) : parent._errorCallback; | |
| 247 _scheduleMicrotask = (specification.scheduleMicrotask != null) ? new _ZoneFunct
ion(this, specification.scheduleMicrotask) : parent._scheduleMicrotask; | |
| 248 _createTimer = (specification.createTimer != null) ? new _ZoneFunction(this, sp
ecification.createTimer) : parent._createTimer; | |
| 249 _createPeriodicTimer = (specification.createPeriodicTimer != null) ? new _ZoneF
unction(this, specification.createPeriodicTimer) : parent._createPeriodicTimer; | |
| 250 _print = (specification.print != null) ? new _ZoneFunction(this, specification.
print) : parent._print; | |
| 251 _fork = (specification.fork != null) ? new _ZoneFunction(this, specification.fo
rk) : parent._fork; | |
| 252 _handleUncaughtError = (specification.handleUncaughtError != null) ? new _ZoneF
unction(this, specification.handleUncaughtError) : parent._handleUncaughtError; | |
| 253 } | |
| 254 Zone get errorZone => _handleUncaughtError.zone; | |
| 255 dynamic runGuarded(f()) { | |
| 256 try { | |
| 257 return run(f); | |
| 258 } | |
| 259 catch (e, s) { | |
| 260 return handleUncaughtError(e, s); | |
| 261 } | |
| 262 } | |
| 263 dynamic runUnaryGuarded(f(arg), arg) { | |
| 264 try { | |
| 265 return runUnary(f, arg); | |
| 266 } | |
| 267 catch (e, s) { | |
| 268 return handleUncaughtError(e, s); | |
| 269 } | |
| 270 } | |
| 271 dynamic runBinaryGuarded(f(arg1, arg2), arg1, arg2) { | |
| 272 try { | |
| 273 return runBinary(f, arg1, arg2); | |
| 274 } | |
| 275 catch (e, s) { | |
| 276 return handleUncaughtError(e, s); | |
| 277 } | |
| 278 } | |
| 279 ZoneCallback bindCallback(f(), { | |
| 280 bool runGuarded : true} | |
| 281 ) { | |
| 282 ZoneCallback registered = registerCallback(f); | |
| 283 if (runGuarded) { | |
| 284 return () => this.runGuarded(registered); | |
| 285 } | |
| 286 else { | |
| 287 return () => this.run(registered); | |
| 288 } | |
| 289 } | |
| 290 ZoneUnaryCallback bindUnaryCallback(f(arg), { | |
| 291 bool runGuarded : true} | |
| 292 ) { | |
| 293 ZoneUnaryCallback registered = registerUnaryCallback(f); | |
| 294 if (runGuarded) { | |
| 295 return (arg) => this.runUnaryGuarded(registered, arg); | |
| 296 } | |
| 297 else { | |
| 298 return (arg) => this.runUnary(registered, arg); | |
| 299 } | |
| 300 } | |
| 301 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), { | |
| 302 bool runGuarded : true} | |
| 303 ) { | |
| 304 ZoneBinaryCallback registered = registerBinaryCallback(f); | |
| 305 if (runGuarded) { | |
| 306 return (arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2); | |
| 307 } | |
| 308 else { | |
| 309 return (arg1, arg2) => this.runBinary(registered, arg1, arg2); | |
| 310 } | |
| 311 } | |
| 312 operator [](Object key) { | |
| 313 var result = _map[key]; | |
| 314 if (result != null || _map.containsKey(key)) return result; | |
| 315 if (parent != null) { | |
| 316 var value = parent[key]; | |
| 317 if (value != null) { | |
| 318 _map[key] = value; | |
| 319 } | |
| 320 return value; | |
| 321 } | |
| 322 assert (this == _ROOT_ZONE); return null; | |
| 323 } | |
| 324 dynamic handleUncaughtError(error, StackTrace stackTrace) { | |
| 325 _ZoneFunction implementation = this._handleUncaughtError; | |
| 326 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 327 return (implementation.function)(implementation.zone, parentDelegate, this, err
or, stackTrace); | |
| 328 } | |
| 329 Zone fork({ | |
| 330 ZoneSpecification specification, Map zoneValues} | |
| 331 ) { | |
| 332 _ZoneFunction implementation = this._fork; | |
| 333 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 334 return ((__x86) => DEVC$RT.cast(__x86, dynamic, Zone, "DynamicCast", """line 78
7, column 12 of dart:async/zone.dart: """, __x86 is Zone, true))((implementation
.function)(implementation.zone, parentDelegate, this, specification, zoneValues)
); | |
| 335 } | |
| 336 dynamic run(f()) { | |
| 337 _ZoneFunction implementation = this._run; | |
| 338 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 339 return (implementation.function)(implementation.zone, parentDelegate, this, f); | |
| 340 } | |
| 341 dynamic runUnary(f(arg), arg) { | |
| 342 _ZoneFunction implementation = this._runUnary; | |
| 343 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 344 return (implementation.function)(implementation.zone, parentDelegate, this, f,
arg); | |
| 345 } | |
| 346 dynamic runBinary(f(arg1, arg2), arg1, arg2) { | |
| 347 _ZoneFunction implementation = this._runBinary; | |
| 348 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 349 return (implementation.function)(implementation.zone, parentDelegate, this, f,
arg1, arg2); | |
| 350 } | |
| 351 ZoneCallback registerCallback(f()) { | |
| 352 _ZoneFunction implementation = this._registerCallback; | |
| 353 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 354 return ((__x87) => DEVC$RT.cast(__x87, dynamic, ZoneCallback, "DynamicCast", ""
"line 820, column 12 of dart:async/zone.dart: """, __x87 is ZoneCallback, true))
((implementation.function)(implementation.zone, parentDelegate, this, f)); | |
| 355 } | |
| 356 ZoneUnaryCallback registerUnaryCallback(f(arg)) { | |
| 357 _ZoneFunction implementation = this._registerUnaryCallback; | |
| 358 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 359 return ((__x88) => DEVC$RT.cast(__x88, dynamic, ZoneUnaryCallback, "DynamicCast
", """line 828, column 12 of dart:async/zone.dart: """, __x88 is ZoneUnaryCallba
ck, true))((implementation.function)(implementation.zone, parentDelegate, this,
f)); | |
| 360 } | |
| 361 ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) { | |
| 362 _ZoneFunction implementation = this._registerBinaryCallback; | |
| 363 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 364 return ((__x89) => DEVC$RT.cast(__x89, dynamic, ZoneBinaryCallback, "DynamicCas
t", """line 836, column 12 of dart:async/zone.dart: """, __x89 is ZoneBinaryCall
back, true))((implementation.function)(implementation.zone, parentDelegate, this
, f)); | |
| 365 } | |
| 366 AsyncError errorCallback(Object error, StackTrace stackTrace) { | |
| 367 final _ZoneFunction implementation = this._errorCallback; | |
| 368 assert (implementation != null); final Zone implementationZone = implementation
.zone; | |
| 369 if (identical(implementationZone, _ROOT_ZONE)) return null; | |
| 370 final ZoneDelegate parentDelegate = _parentDelegate(DEVC$RT.cast(implementation
Zone, Zone, _Zone, "ImplicitCast", """line 845, column 57 of dart:async/zone.dar
t: """, implementationZone is _Zone, true)); | |
| 371 return ((__x90) => DEVC$RT.cast(__x90, dynamic, AsyncError, "DynamicCast", """l
ine 846, column 12 of dart:async/zone.dart: """, __x90 is AsyncError, true))((im
plementation.function)(implementationZone, parentDelegate, this, error, stackTra
ce)); | |
| 372 } | |
| 373 void scheduleMicrotask(void f()) { | |
| 374 _ZoneFunction implementation = this._scheduleMicrotask; | |
| 375 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 376 return (implementation.function)(implementation.zone, parentDelegate, this, f); | |
| 377 } | |
| 378 Timer createTimer(Duration duration, void f()) { | |
| 379 _ZoneFunction implementation = this._createTimer; | |
| 380 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 381 return ((__x91) => DEVC$RT.cast(__x91, dynamic, Timer, "DynamicCast", """line 8
62, column 12 of dart:async/zone.dart: """, __x91 is Timer, true))((implementati
on.function)(implementation.zone, parentDelegate, this, duration, f)); | |
| 382 } | |
| 383 Timer createPeriodicTimer(Duration duration, void f(Timer timer)) { | |
| 384 _ZoneFunction implementation = this._createPeriodicTimer; | |
| 385 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 386 return ((__x92) => DEVC$RT.cast(__x92, dynamic, Timer, "DynamicCast", """line 8
70, column 12 of dart:async/zone.dart: """, __x92 is Timer, true))((implementati
on.function)(implementation.zone, parentDelegate, this, duration, f)); | |
| 387 } | |
| 388 void print(String line) { | |
| 389 _ZoneFunction implementation = this._print; | |
| 390 assert (implementation != null); ZoneDelegate parentDelegate = _parentDelegate(
implementation.zone); | |
| 391 return (implementation.function)(implementation.zone, parentDelegate, this, lin
e); | |
| 392 } | |
| 393 } | |
| 394 void _rootHandleUncaughtError(Zone self, ZoneDelegate parent, Zone zone, error,
StackTrace stackTrace) { | |
| 395 _schedulePriorityAsyncCallback(() { | |
| 396 throw new _UncaughtAsyncError(error, stackTrace); | |
| 397 } | |
| 398 ); | |
| 399 } | |
| 400 dynamic _rootRun(Zone self, ZoneDelegate parent, Zone zone, f()) { | |
| 401 if (Zone._current == zone) return f(); | |
| 402 Zone old = Zone._enter(zone); | |
| 403 try { | |
| 404 return f(); | |
| 405 } | |
| 406 finally { | |
| 407 Zone._leave(old); | |
| 408 } | |
| 409 } | |
| 410 dynamic _rootRunUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg) { | |
| 411 if (Zone._current == zone) return f(arg); | |
| 412 Zone old = Zone._enter(zone); | |
| 413 try { | |
| 414 return f(arg); | |
| 415 } | |
| 416 finally { | |
| 417 Zone._leave(old); | |
| 418 } | |
| 419 } | |
| 420 dynamic _rootRunBinary(Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)
, arg1, arg2) { | |
| 421 if (Zone._current == zone) return f(arg1, arg2); | |
| 422 Zone old = Zone._enter(zone); | |
| 423 try { | |
| 424 return f(arg1, arg2); | |
| 425 } | |
| 426 finally { | |
| 427 Zone._leave(old); | |
| 428 } | |
| 429 } | |
| 430 ZoneCallback _rootRegisterCallback(Zone self, ZoneDelegate parent, Zone zone, f
()) { | |
| 431 return f; | |
| 432 } | |
| 433 ZoneUnaryCallback _rootRegisterUnaryCallback(Zone self, ZoneDelegate parent, Zo
ne zone, f(arg)) { | |
| 434 return f; | |
| 435 } | |
| 436 ZoneBinaryCallback _rootRegisterBinaryCallback(Zone self, ZoneDelegate parent,
Zone zone, f(arg1, arg2)) { | |
| 437 return f; | |
| 438 } | |
| 439 AsyncError _rootErrorCallback(Zone self, ZoneDelegate parent, Zone zone, Object
error, StackTrace stackTrace) => null; | |
| 440 void _rootScheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) { | |
| 441 if (!identical(_ROOT_ZONE, zone)) { | |
| 442 bool hasErrorHandler = !_ROOT_ZONE.inSameErrorZone(zone); | |
| 443 f = zone.bindCallback(f, runGuarded: hasErrorHandler); | |
| 444 } | |
| 445 _scheduleAsyncCallback(f); | |
| 446 } | |
| 447 Timer _rootCreateTimer(Zone self, ZoneDelegate parent, Zone zone, Duration dura
tion, void callback()) { | |
| 448 if (!identical(_ROOT_ZONE, zone)) { | |
| 449 callback = zone.bindCallback(callback); | |
| 450 } | |
| 451 return Timer._createTimer(duration, callback); | |
| 452 } | |
| 453 Timer _rootCreatePeriodicTimer(Zone self, ZoneDelegate parent, Zone zone, Durat
ion duration, void callback(Timer timer)) { | |
| 454 if (!identical(_ROOT_ZONE, zone)) { | |
| 455 callback = ((__x95) => DEVC$RT.cast(__x95, ZoneUnaryCallback, __CastType93, "Com
positeCast", """line 962, column 16 of dart:async/zone.dart: """, __x95 is __Cas
tType93, false))(zone.bindUnaryCallback(callback)); | |
| 456 } | |
| 457 return Timer._createPeriodicTimer(duration, callback); | |
| 458 } | |
| 459 void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, String line) { | |
| 460 printToConsole(line); | |
| 461 } | |
| 462 void _printToZone(String line) { | |
| 463 Zone.current.print(line); | |
| 464 } | |
| 465 Zone _rootFork(Zone self, ZoneDelegate parent, Zone zone, ZoneSpecification spe
cification, Map zoneValues) { | |
| 466 printToZone = _printToZone; | |
| 467 if (specification == null) { | |
| 468 specification = const ZoneSpecification(); | |
| 469 } | |
| 470 else if (specification is! _ZoneSpecification) { | |
| 471 throw new ArgumentError("ZoneSpecifications must be instantiated" " with the pro
vided constructor."); | |
| 472 } | |
| 473 Map valueMap; | |
| 474 if (zoneValues == null) { | |
| 475 if (zone is _Zone) { | |
| 476 valueMap = zone._map; | |
| 477 } | |
| 478 else { | |
| 479 valueMap = new HashMap(); | |
| 480 } | |
| 481 } | |
| 482 else { | |
| 483 valueMap = new HashMap.from(zoneValues); | |
| 484 } | |
| 485 return new _CustomZone(DEVC$RT.cast(zone, Zone, _Zone, "ImplicitCast", """line
999, column 26 of dart:async/zone.dart: """, zone is _Zone, true), specification
, valueMap); | |
| 486 } | |
| 487 class _RootZoneSpecification implements ZoneSpecification {HandleUncaughtErrorH
andler get handleUncaughtError => _rootHandleUncaughtError; | |
| 488 RunHandler get run => _rootRun; | |
| 489 RunUnaryHandler get runUnary => _rootRunUnary; | |
| 490 RunBinaryHandler get runBinary => _rootRunBinary; | |
| 491 RegisterCallbackHandler get registerCallback => _rootRegisterCallback; | |
| 492 RegisterUnaryCallbackHandler get registerUnaryCallback => _rootRegisterUnaryCal
lback; | |
| 493 RegisterBinaryCallbackHandler get registerBinaryCallback => _rootRegisterBinary
Callback; | |
| 494 ErrorCallbackHandler get errorCallback => _rootErrorCallback; | |
| 495 ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask; | |
| 496 CreateTimerHandler get createTimer => _rootCreateTimer; | |
| 497 CreatePeriodicTimerHandler get createPeriodicTimer => _rootCreatePeriodicTimer; | |
| 498 PrintHandler get print => _rootPrint; | |
| 499 ForkHandler get fork => _rootFork; | |
| 500 } | |
| 501 class _RootZone extends _Zone {const _RootZone(); | |
| 502 _ZoneFunction get _run => const _ZoneFunction(_ROOT_ZONE, _rootRun); | |
| 503 _ZoneFunction get _runUnary => const _ZoneFunction(_ROOT_ZONE, _rootRunUnary); | |
| 504 _ZoneFunction get _runBinary => const _ZoneFunction(_ROOT_ZONE, _rootRunBinary)
; | |
| 505 _ZoneFunction get _registerCallback => const _ZoneFunction(_ROOT_ZONE, _rootReg
isterCallback); | |
| 506 _ZoneFunction get _registerUnaryCallback => const _ZoneFunction(_ROOT_ZONE, _ro
otRegisterUnaryCallback); | |
| 507 _ZoneFunction get _registerBinaryCallback => const _ZoneFunction(_ROOT_ZONE, _r
ootRegisterBinaryCallback); | |
| 508 _ZoneFunction get _errorCallback => const _ZoneFunction(_ROOT_ZONE, _rootErrorC
allback); | |
| 509 _ZoneFunction get _scheduleMicrotask => const _ZoneFunction(_ROOT_ZONE, _rootSc
heduleMicrotask); | |
| 510 _ZoneFunction get _createTimer => const _ZoneFunction(_ROOT_ZONE, _rootCreateTi
mer); | |
| 511 _ZoneFunction get _createPeriodicTimer => const _ZoneFunction(_ROOT_ZONE, _root
CreatePeriodicTimer); | |
| 512 _ZoneFunction get _print => const _ZoneFunction(_ROOT_ZONE, _rootPrint); | |
| 513 _ZoneFunction get _fork => const _ZoneFunction(_ROOT_ZONE, _rootFork); | |
| 514 _ZoneFunction get _handleUncaughtError => const _ZoneFunction(_ROOT_ZONE, _root
HandleUncaughtError); | |
| 515 _Zone get parent => null; | |
| 516 Map get _map => _rootMap; | |
| 517 static Map _rootMap = new HashMap(); | |
| 518 static ZoneDelegate _rootDelegate; | |
| 519 ZoneDelegate get _delegate { | |
| 520 if (_rootDelegate != null) return _rootDelegate; | |
| 521 return _rootDelegate = new _ZoneDelegate(this); | |
| 522 } | |
| 523 Zone get errorZone => this; | |
| 524 dynamic runGuarded(f()) { | |
| 525 try { | |
| 526 if (identical(_ROOT_ZONE, Zone._current)) { | |
| 527 return f(); | |
| 528 } | |
| 529 return _rootRun(null, null, this, f); | |
| 530 } | |
| 531 catch (e, s) { | |
| 532 return handleUncaughtError(e, s); | |
| 533 } | |
| 534 } | |
| 535 dynamic runUnaryGuarded(f(arg), arg) { | |
| 536 try { | |
| 537 if (identical(_ROOT_ZONE, Zone._current)) { | |
| 538 return f(arg); | |
| 539 } | |
| 540 return _rootRunUnary(null, null, this, f, arg); | |
| 541 } | |
| 542 catch (e, s) { | |
| 543 return handleUncaughtError(e, s); | |
| 544 } | |
| 545 } | |
| 546 dynamic runBinaryGuarded(f(arg1, arg2), arg1, arg2) { | |
| 547 try { | |
| 548 if (identical(_ROOT_ZONE, Zone._current)) { | |
| 549 return f(arg1, arg2); | |
| 550 } | |
| 551 return _rootRunBinary(null, null, this, f, arg1, arg2); | |
| 552 } | |
| 553 catch (e, s) { | |
| 554 return handleUncaughtError(e, s); | |
| 555 } | |
| 556 } | |
| 557 ZoneCallback bindCallback(f(), { | |
| 558 bool runGuarded : true} | |
| 559 ) { | |
| 560 if (runGuarded) { | |
| 561 return () => this.runGuarded(f); | |
| 562 } | |
| 563 else { | |
| 564 return () => this.run(f); | |
| 565 } | |
| 566 } | |
| 567 ZoneUnaryCallback bindUnaryCallback(f(arg), { | |
| 568 bool runGuarded : true} | |
| 569 ) { | |
| 570 if (runGuarded) { | |
| 571 return (arg) => this.runUnaryGuarded(f, arg); | |
| 572 } | |
| 573 else { | |
| 574 return (arg) => this.runUnary(f, arg); | |
| 575 } | |
| 576 } | |
| 577 ZoneBinaryCallback bindBinaryCallback(f(arg1, arg2), { | |
| 578 bool runGuarded : true} | |
| 579 ) { | |
| 580 if (runGuarded) { | |
| 581 return (arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2); | |
| 582 } | |
| 583 else { | |
| 584 return (arg1, arg2) => this.runBinary(f, arg1, arg2); | |
| 585 } | |
| 586 } | |
| 587 operator [](Object key) => null; | |
| 588 dynamic handleUncaughtError(error, StackTrace stackTrace) { | |
| 589 return _rootHandleUncaughtError(null, null, this, error, stackTrace); | |
| 590 } | |
| 591 Zone fork({ | |
| 592 ZoneSpecification specification, Map zoneValues} | |
| 593 ) { | |
| 594 return _rootFork(null, null, this, specification, zoneValues); | |
| 595 } | |
| 596 dynamic run(f()) { | |
| 597 if (identical(Zone._current, _ROOT_ZONE)) return f(); | |
| 598 return _rootRun(null, null, this, f); | |
| 599 } | |
| 600 dynamic runUnary(f(arg), arg) { | |
| 601 if (identical(Zone._current, _ROOT_ZONE)) return f(arg); | |
| 602 return _rootRunUnary(null, null, this, f, arg); | |
| 603 } | |
| 604 dynamic runBinary(f(arg1, arg2), arg1, arg2) { | |
| 605 if (identical(Zone._current, _ROOT_ZONE)) return f(arg1, arg2); | |
| 606 return _rootRunBinary(null, null, this, f, arg1, arg2); | |
| 607 } | |
| 608 ZoneCallback registerCallback(f()) => f; | |
| 609 ZoneUnaryCallback registerUnaryCallback(f(arg)) => f; | |
| 610 ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) => f; | |
| 611 AsyncError errorCallback(Object error, StackTrace stackTrace) => null; | |
| 612 void scheduleMicrotask(void f()) { | |
| 613 _rootScheduleMicrotask(null, null, this, f); | |
| 614 } | |
| 615 Timer createTimer(Duration duration, void f()) { | |
| 616 return Timer._createTimer(duration, f); | |
| 617 } | |
| 618 Timer createPeriodicTimer(Duration duration, void f(Timer timer)) { | |
| 619 return Timer._createPeriodicTimer(duration, f); | |
| 620 } | |
| 621 void print(String line) { | |
| 622 printToConsole(line); | |
| 623 } | |
| 624 } | |
| 625 const _ROOT_ZONE = const _RootZone(); | |
| 626 dynamic runZoned(body(), { | |
| 627 Map zoneValues, ZoneSpecification zoneSpecification, Function onError} | |
| 628 ) { | |
| 629 HandleUncaughtErrorHandler errorHandler; | |
| 630 if (onError != null) { | |
| 631 errorHandler = (Zone self, ZoneDelegate parent, Zone zone, error, StackTrace sta
ckTrace) { | |
| 632 try { | |
| 633 if (onError is ZoneBinaryCallback) { | |
| 634 return self.parent.runBinary(onError, error, stackTrace); | |
| 635 } | |
| 636 return self.parent.runUnary(DEVC$RT.cast(onError, Function, __CastType96, "Impl
icitCast", """line 1228, column 37 of dart:async/zone.dart: """, onError is __Ca
stType96, true), error); | |
| 637 } | |
| 638 catch (e, s) { | |
| 639 if (identical(e, error)) { | |
| 640 return parent.handleUncaughtError(zone, error, stackTrace); | |
| 641 } | |
| 642 else { | |
| 643 return parent.handleUncaughtError(zone, e, s); | |
| 644 } | |
| 645 } | |
| 646 } | |
| 647 ; | |
| 648 } | |
| 649 if (zoneSpecification == null) { | |
| 650 zoneSpecification = new ZoneSpecification(handleUncaughtError: errorHandler); | |
| 651 } | |
| 652 else if (errorHandler != null) { | |
| 653 zoneSpecification = new ZoneSpecification.from(zoneSpecification, handleUncaught
Error: errorHandler); | |
| 654 } | |
| 655 Zone zone = Zone.current.fork(specification: zoneSpecification, zoneValues: zon
eValues); | |
| 656 if (onError != null) { | |
| 657 return zone.runGuarded(body); | |
| 658 } | |
| 659 else { | |
| 660 return zone.run(body); | |
| 661 } | |
| 662 } | |
| 663 typedef void __CastType93(Timer __u94); | |
| 664 typedef dynamic __CastType96(dynamic __u97); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1148283010:
Remove dart backend (Closed)
Base URL: https://github.com/dart-lang/dev_compiler.git@master