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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: lib/runtime/dart/_isolate_helper.js

Issue 1317933005: Some preliminary support for quasi-generics (Closed) Base URL: https://github.com/dart-lang/dev_compiler.git@master
Patch Set: Address comments Created 5 years, 3 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
« no previous file with comments | « lib/runtime/dart/_internal.js ('k') | lib/runtime/dart/_js_embedded_names.js » ('j') | lib/src/checker/resolver.dart » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 dart_library.library('dart/_isolate_helper', null, /* Imports */[
2 "dart_runtime/dart",
3 'dart/core',
4 'dart/_interceptors',
5 'dart/_js_helper',
6 'dart/isolate',
7 'dart/_foreign_helper',
8 'dart/collection',
9 'dart/async'
10 ], /* Lazy imports */[
11 'dart/_native_typed_data',
12 'dart/_js_embedded_names'
13 ], function(exports, dart, core, _interceptors, _js_helper, isolate, _foreign_he lper, collection, async, _native_typed_data, _js_embedded_names) {
14 'use strict';
15 let dartx = dart.dartx;
16 function _serializeMessage(message) {
17 return new _Serializer().serialize(message);
18 }
19 dart.fn(_serializeMessage);
20 function _deserializeMessage(message) {
21 return new _Deserializer().deserialize(message);
22 }
23 dart.fn(_deserializeMessage);
24 function _clone(message) {
25 let serializer = new _Serializer({serializeSendPorts: false});
26 let deserializer = new _Deserializer();
27 return deserializer.deserialize(serializer.serialize(message));
28 }
29 dart.fn(_clone);
30 let _serializeSendPorts = Symbol('_serializeSendPorts');
31 let _workerId = Symbol('_workerId');
32 let _isolateId = Symbol('_isolateId');
33 let _receivePortId = Symbol('_receivePortId');
34 let _id = Symbol('_id');
35 let _receivePort = Symbol('_receivePort');
36 class _Serializer extends core.Object {
37 _Serializer(opts) {
38 let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.seria lizeSendPorts : true;
39 this.serializedObjectIds = core.Map$(dart.dynamic, core.int).identity();
40 this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
41 }
42 serialize(x) {
43 if (dart.notNull(this.isPrimitive(x)))
44 return this.serializePrimitive(x);
45 let serializationId = this.serializedObjectIds.get(x);
46 if (serializationId != null)
47 return this.makeRef(serializationId);
48 serializationId = this.serializedObjectIds.length;
49 this.serializedObjectIds.set(x, serializationId);
50 if (dart.is(x, _native_typed_data.NativeByteBuffer))
51 return this.serializeByteBuffer(dart.as(x, _native_typed_data.NativeByte Buffer));
52 if (dart.is(x, _native_typed_data.NativeTypedData))
53 return this.serializeTypedData(dart.as(x, _native_typed_data.NativeTyped Data));
54 if (dart.is(x, _interceptors.JSIndexable))
55 return this.serializeJSIndexable(dart.as(x, _interceptors.JSIndexable));
56 if (dart.is(x, _js_helper.InternalMap))
57 return this.serializeMap(dart.as(x, core.Map));
58 if (dart.is(x, _interceptors.JSObject))
59 return this.serializeJSObject(dart.as(x, _interceptors.JSObject));
60 if (dart.is(x, _interceptors.Interceptor))
61 this.unsupported(x);
62 if (dart.is(x, isolate.RawReceivePort)) {
63 this.unsupported(x, "RawReceivePorts can't be transmitted:");
64 }
65 if (dart.is(x, _NativeJsSendPort))
66 return this.serializeJsSendPort(dart.as(x, _NativeJsSendPort));
67 if (dart.is(x, _WorkerSendPort))
68 return this.serializeWorkerSendPort(dart.as(x, _WorkerSendPort));
69 if (dart.is(x, core.Function))
70 return this.serializeClosure(dart.as(x, core.Function));
71 return this.serializeDartObject(x);
72 }
73 unsupported(x, message) {
74 if (message === void 0)
75 message = null;
76 if (message == null)
77 message = "Can't transmit:";
78 dart.throw(new core.UnsupportedError(`${message} ${x}`));
79 }
80 makeRef(serializationId) {
81 return ["ref", serializationId];
82 }
83 isPrimitive(x) {
84 return x == null || typeof x == 'string' || dart.is(x, core.num) || typeof x == 'boolean';
85 }
86 serializePrimitive(primitive) {
87 return primitive;
88 }
89 serializeByteBuffer(buffer) {
90 return ["buffer", buffer];
91 }
92 serializeTypedData(data) {
93 return ["typed", data];
94 }
95 serializeJSIndexable(indexable) {
96 dart.assert(!(typeof indexable == 'string'));
97 let serialized = dart.as(this.serializeArray(dart.as(indexable, _intercept ors.JSArray)), core.List);
98 if (dart.is(indexable, _interceptors.JSFixedArray))
99 return ["fixed", serialized];
100 if (dart.is(indexable, _interceptors.JSExtendableArray))
101 return ["extendable", serialized];
102 if (dart.is(indexable, _interceptors.JSMutableArray))
103 return ["mutable", serialized];
104 if (dart.is(indexable, _interceptors.JSArray))
105 return ["const", serialized];
106 this.unsupported(indexable, "Can't serialize indexable: ");
107 return null;
108 }
109 serializeArray(x) {
110 let serialized = [];
111 serialized[dartx.length] = x[dartx.length];
112 for (let i = 0; dart.notNull(i) < dart.notNull(x[dartx.length]); i = dart. notNull(i) + 1) {
113 serialized[dartx.set](i, this.serialize(x[dartx.get](i)));
114 }
115 return serialized;
116 }
117 serializeArrayInPlace(x) {
118 for (let i = 0; dart.notNull(i) < dart.notNull(x[dartx.length]); i = dart. notNull(i) + 1) {
119 x[dartx.set](i, this.serialize(x[dartx.get](i)));
120 }
121 return x;
122 }
123 serializeMap(x) {
124 let serializeTearOff = dart.bind(this, 'serialize');
125 return ['map', x.keys[dartx.map](dart.as(serializeTearOff, __CastType0))[d artx.toList](), x.values[dartx.map](dart.as(serializeTearOff, dart.functionType( dart.dynamic, [dart.dynamic])))[dartx.toList]()];
126 }
127 serializeJSObject(x) {
128 if (!!x.constructor && x.constructor !== Object) {
129 this.unsupported(x, "Only plain JS Objects are supported:");
130 }
131 let keys = dart.as(Object.keys(x), core.List);
132 let values = [];
133 values[dartx.length] = keys[dartx.length];
134 for (let i = 0; dart.notNull(i) < dart.notNull(keys[dartx.length]); i = da rt.notNull(i) + 1) {
135 values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
136 }
137 return ['js-object', keys, values];
138 }
139 serializeWorkerSendPort(x) {
140 if (dart.notNull(this[_serializeSendPorts])) {
141 return ['sendport', x[_workerId], x[_isolateId], x[_receivePortId]];
142 }
143 return ['raw sendport', x];
144 }
145 serializeJsSendPort(x) {
146 if (dart.notNull(this[_serializeSendPorts])) {
147 let workerId = exports._globalState.currentManagerId;
148 return ['sendport', workerId, x[_isolateId], x[_receivePort][_id]];
149 }
150 return ['raw sendport', x];
151 }
152 serializeCapability(x) {
153 return ['capability', x[_id]];
154 }
155 serializeClosure(x) {
156 let name = IsolateNatives._getJSFunctionName(x);
157 if (name == null) {
158 this.unsupported(x, "Closures can't be transmitted:");
159 }
160 return ['function', name];
161 }
162 serializeDartObject(x) {
163 let classExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_n ames.CLASS_ID_EXTRACTOR);
164 let fieldsExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_ names.CLASS_FIELDS_EXTRACTOR);
165 let classId = classExtractor(x);
166 let fields = dart.as(fieldsExtractor(x), core.List);
167 return ['dart', classId, this.serializeArrayInPlace(dart.as(fields, _inter ceptors.JSArray))];
168 }
169 }
170 dart.setSignature(_Serializer, {
171 constructors: () => ({_Serializer: [_Serializer, [], {serializeSendPorts: da rt.dynamic}]}),
172 methods: () => ({
173 serialize: [dart.dynamic, [dart.dynamic]],
174 unsupported: [dart.void, [dart.dynamic], [core.String]],
175 makeRef: [dart.dynamic, [core.int]],
176 isPrimitive: [core.bool, [dart.dynamic]],
177 serializePrimitive: [dart.dynamic, [dart.dynamic]],
178 serializeByteBuffer: [dart.dynamic, [_native_typed_data.NativeByteBuffer]] ,
179 serializeTypedData: [dart.dynamic, [_native_typed_data.NativeTypedData]],
180 serializeJSIndexable: [dart.dynamic, [_interceptors.JSIndexable]],
181 serializeArray: [dart.dynamic, [_interceptors.JSArray]],
182 serializeArrayInPlace: [dart.dynamic, [_interceptors.JSArray]],
183 serializeMap: [dart.dynamic, [core.Map]],
184 serializeJSObject: [dart.dynamic, [_interceptors.JSObject]],
185 serializeWorkerSendPort: [dart.dynamic, [_WorkerSendPort]],
186 serializeJsSendPort: [dart.dynamic, [_NativeJsSendPort]],
187 serializeCapability: [dart.dynamic, [CapabilityImpl]],
188 serializeClosure: [dart.dynamic, [core.Function]],
189 serializeDartObject: [dart.dynamic, [dart.dynamic]]
190 })
191 });
192 let _adjustSendPorts = Symbol('_adjustSendPorts');
193 class _Deserializer extends core.Object {
194 _Deserializer(opts) {
195 let adjustSendPorts = opts && 'adjustSendPorts' in opts ? opts.adjustSendP orts : true;
196 this.deserializedObjects = core.List.new();
197 this[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
198 }
199 deserialize(x) {
200 if (dart.notNull(this.isPrimitive(x)))
201 return this.deserializePrimitive(x);
202 if (!dart.is(x, _interceptors.JSArray))
203 dart.throw(new core.ArgumentError(`Bad serialized message: ${x}`));
204 switch (dart.dload(x, 'first')) {
205 case "ref":
206 {
207 return this.deserializeRef(x);
208 }
209 case "buffer":
210 {
211 return this.deserializeByteBuffer(x);
212 }
213 case "typed":
214 {
215 return this.deserializeTypedData(x);
216 }
217 case "fixed":
218 {
219 return this.deserializeFixed(x);
220 }
221 case "extendable":
222 {
223 return this.deserializeExtendable(x);
224 }
225 case "mutable":
226 {
227 return this.deserializeMutable(x);
228 }
229 case "const":
230 {
231 return this.deserializeConst(x);
232 }
233 case "map":
234 {
235 return this.deserializeMap(x);
236 }
237 case "sendport":
238 {
239 return this.deserializeSendPort(x);
240 }
241 case "raw sendport":
242 {
243 return this.deserializeRawSendPort(x);
244 }
245 case "js-object":
246 {
247 return this.deserializeJSObject(x);
248 }
249 case "function":
250 {
251 return this.deserializeClosure(x);
252 }
253 case "dart":
254 {
255 return this.deserializeDartObject(x);
256 }
257 default:
258 {
259 dart.throw(`couldn't deserialize: ${x}`);
260 }
261 }
262 }
263 isPrimitive(x) {
264 return x == null || typeof x == 'string' || dart.is(x, core.num) || typeof x == 'boolean';
265 }
266 deserializePrimitive(x) {
267 return x;
268 }
269 deserializeRef(x) {
270 dart.assert(dart.equals(dart.dindex(x, 0), 'ref'));
271 let serializationId = dart.as(dart.dindex(x, 1), core.int);
272 return this.deserializedObjects[dartx.get](serializationId);
273 }
274 deserializeByteBuffer(x) {
275 dart.assert(dart.equals(dart.dindex(x, 0), 'buffer'));
276 let result = dart.as(dart.dindex(x, 1), _native_typed_data.NativeByteBuffe r);
277 this.deserializedObjects[dartx.add](result);
278 return result;
279 }
280 deserializeTypedData(x) {
281 dart.assert(dart.equals(dart.dindex(x, 0), 'typed'));
282 let result = dart.as(dart.dindex(x, 1), _native_typed_data.NativeTypedData );
283 this.deserializedObjects[dartx.add](result);
284 return result;
285 }
286 deserializeArrayInPlace(x) {
287 for (let i = 0; dart.notNull(i) < dart.notNull(x[dartx.length]); i = dart. notNull(i) + 1) {
288 x[dartx.set](i, this.deserialize(x[dartx.get](i)));
289 }
290 return x;
291 }
292 deserializeFixed(x) {
293 dart.assert(dart.equals(dart.dindex(x, 0), 'fixed'));
294 let result = dart.as(dart.dindex(x, 1), core.List);
295 this.deserializedObjects[dartx.add](result);
296 return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.a s(result, _interceptors.JSArray)));
297 }
298 deserializeExtendable(x) {
299 dart.assert(dart.equals(dart.dindex(x, 0), 'extendable'));
300 let result = dart.as(dart.dindex(x, 1), core.List);
301 this.deserializedObjects[dartx.add](result);
302 return _interceptors.JSArray.markGrowable(this.deserializeArrayInPlace(dar t.as(result, _interceptors.JSArray)));
303 }
304 deserializeMutable(x) {
305 dart.assert(dart.equals(dart.dindex(x, 0), 'mutable'));
306 let result = dart.as(dart.dindex(x, 1), core.List);
307 this.deserializedObjects[dartx.add](result);
308 return this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray) );
309 }
310 deserializeConst(x) {
311 dart.assert(dart.equals(dart.dindex(x, 0), 'const'));
312 let result = dart.as(dart.dindex(x, 1), core.List);
313 this.deserializedObjects[dartx.add](result);
314 return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.a s(result, _interceptors.JSArray)));
315 }
316 deserializeMap(x) {
317 dart.assert(dart.equals(dart.dindex(x, 0), 'map'));
318 let keys = dart.as(dart.dindex(x, 1), core.List);
319 let values = dart.as(dart.dindex(x, 2), core.List);
320 let result = dart.map();
321 this.deserializedObjects[dartx.add](result);
322 keys = keys[dartx.map](dart.bind(this, 'deserialize'))[dartx.toList]();
323 for (let i = 0; dart.notNull(i) < dart.notNull(keys[dartx.length]); i = da rt.notNull(i) + 1) {
324 result.set(keys[dartx.get](i), this.deserialize(values[dartx.get](i)));
325 }
326 return result;
327 }
328 deserializeSendPort(x) {
329 dart.assert(dart.equals(dart.dindex(x, 0), 'sendport'));
330 let managerId = dart.as(dart.dindex(x, 1), core.int);
331 let isolateId = dart.as(dart.dindex(x, 2), core.int);
332 let receivePortId = dart.as(dart.dindex(x, 3), core.int);
333 let result = null;
334 if (managerId == exports._globalState.currentManagerId) {
335 let isolate = exports._globalState.isolates.get(isolateId);
336 if (isolate == null)
337 return null;
338 let receivePort = isolate.lookup(receivePortId);
339 if (receivePort == null)
340 return null;
341 result = new _NativeJsSendPort(receivePort, isolateId);
342 } else {
343 result = new _WorkerSendPort(managerId, isolateId, receivePortId);
344 }
345 this.deserializedObjects[dartx.add](result);
346 return result;
347 }
348 deserializeRawSendPort(x) {
349 dart.assert(dart.equals(dart.dindex(x, 0), 'raw sendport'));
350 let result = dart.as(dart.dindex(x, 1), isolate.SendPort);
351 this.deserializedObjects[dartx.add](result);
352 return result;
353 }
354 deserializeJSObject(x) {
355 dart.assert(dart.equals(dart.dindex(x, 0), 'js-object'));
356 let keys = dart.as(dart.dindex(x, 1), core.List);
357 let values = dart.as(dart.dindex(x, 2), core.List);
358 let o = {};
359 this.deserializedObjects[dartx.add](o);
360 for (let i = 0; dart.notNull(i) < dart.notNull(keys[dartx.length]); i = da rt.notNull(i) + 1) {
361 o[keys[dartx.get](i)] = this.deserialize(values[dartx.get](i));
362 }
363 return o;
364 }
365 deserializeClosure(x) {
366 dart.assert(dart.equals(dart.dindex(x, 0), 'function'));
367 let name = dart.as(dart.dindex(x, 1), core.String);
368 let result = dart.as(IsolateNatives._getJSFunctionFromName(name), core.Fun ction);
369 this.deserializedObjects[dartx.add](result);
370 return result;
371 }
372 deserializeDartObject(x) {
373 dart.assert(dart.equals(dart.dindex(x, 0), 'dart'));
374 let classId = dart.as(dart.dindex(x, 1), core.String);
375 let fields = dart.as(dart.dindex(x, 2), core.List);
376 let instanceFromClassId = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embed ded_names.INSTANCE_FROM_CLASS_ID);
377 let initializeObject = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded _names.INITIALIZE_EMPTY_INSTANCE);
378 let emptyInstance = instanceFromClassId(classId);
379 this.deserializedObjects[dartx.add](emptyInstance);
380 this.deserializeArrayInPlace(dart.as(fields, _interceptors.JSArray));
381 return initializeObject(classId, emptyInstance, fields);
382 }
383 }
384 dart.setSignature(_Deserializer, {
385 constructors: () => ({_Deserializer: [_Deserializer, [], {adjustSendPorts: d art.dynamic}]}),
386 methods: () => ({
387 deserialize: [dart.dynamic, [dart.dynamic]],
388 isPrimitive: [core.bool, [dart.dynamic]],
389 deserializePrimitive: [dart.dynamic, [dart.dynamic]],
390 deserializeRef: [dart.dynamic, [dart.dynamic]],
391 deserializeByteBuffer: [_native_typed_data.NativeByteBuffer, [dart.dynamic ]],
392 deserializeTypedData: [_native_typed_data.NativeTypedData, [dart.dynamic]] ,
393 deserializeArrayInPlace: [core.List, [_interceptors.JSArray]],
394 deserializeFixed: [core.List, [dart.dynamic]],
395 deserializeExtendable: [core.List, [dart.dynamic]],
396 deserializeMutable: [core.List, [dart.dynamic]],
397 deserializeConst: [core.List, [dart.dynamic]],
398 deserializeMap: [core.Map, [dart.dynamic]],
399 deserializeSendPort: [isolate.SendPort, [dart.dynamic]],
400 deserializeRawSendPort: [isolate.SendPort, [dart.dynamic]],
401 deserializeJSObject: [dart.dynamic, [dart.dynamic]],
402 deserializeClosure: [core.Function, [dart.dynamic]],
403 deserializeDartObject: [dart.dynamic, [dart.dynamic]]
404 })
405 });
406 let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dyn amic, [dart.dynamic]));
407 function _callInIsolate(isolate, func) {
408 let result = isolate.eval(func);
409 exports._globalState.topEventLoop.run();
410 return result;
411 }
412 dart.fn(_callInIsolate, () => dart.definiteFunctionType(dart.dynamic, [_Isolat eContext, core.Function]));
413 let _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
414 function enterJsAsync() {
415 let o = exports._globalState.topEventLoop;
416 o[_activeJsAsyncCount] = dart.notNull(o[_activeJsAsyncCount]) + 1;
417 }
418 dart.fn(enterJsAsync);
419 function leaveJsAsync() {
420 let o = exports._globalState.topEventLoop;
421 o[_activeJsAsyncCount] = dart.notNull(o[_activeJsAsyncCount]) - 1;
422 dart.assert(dart.notNull(exports._globalState.topEventLoop[_activeJsAsyncCou nt]) >= 0);
423 }
424 dart.fn(leaveJsAsync);
425 function isWorker() {
426 return exports._globalState.isWorker;
427 }
428 dart.fn(isWorker, core.bool, []);
429 function _currentIsolate() {
430 return exports._globalState.currentContext;
431 }
432 dart.fn(_currentIsolate, () => dart.definiteFunctionType(_IsolateContext, [])) ;
433 function startRootIsolate(entry, args) {
434 args = args;
435 if (args == null)
436 args = [];
437 if (!dart.is(args, core.List)) {
438 dart.throw(new core.ArgumentError(`Arguments to main must be a List: ${arg s}`));
439 }
440 exports._globalState = new _Manager(dart.as(entry, core.Function));
441 if (dart.notNull(exports._globalState.isWorker))
442 return;
443 let rootContext = new _IsolateContext();
444 exports._globalState.rootContext = rootContext;
445 exports._globalState.currentContext = rootContext;
446 if (dart.is(entry, _MainFunctionArgs)) {
447 rootContext.eval(dart.fn(() => {
448 dart.dcall(entry, args);
449 }));
450 } else if (dart.is(entry, _MainFunctionArgsMessage)) {
451 rootContext.eval(dart.fn(() => {
452 dart.dcall(entry, args, null);
453 }));
454 } else {
455 rootContext.eval(dart.as(entry, core.Function));
456 }
457 exports._globalState.topEventLoop.run();
458 }
459 dart.fn(startRootIsolate, dart.void, [dart.dynamic, dart.dynamic]);
460 dart.copyProperties(exports, {
461 get _globalState() {
462 return dart.as(dart.globalState, _Manager);
463 },
464 set _globalState(val) {
465 dart.globalState = val;
466 }
467 });
468 let _nativeDetectEnvironment = Symbol('_nativeDetectEnvironment');
469 let _nativeInitWorkerMessageHandler = Symbol('_nativeInitWorkerMessageHandler' );
470 class _Manager extends core.Object {
471 get useWorkers() {
472 return this.supportsWorkers;
473 }
474 _Manager(entry) {
475 this.entry = entry;
476 this.nextIsolateId = 0;
477 this.currentManagerId = 0;
478 this.nextManagerId = 1;
479 this.currentContext = null;
480 this.rootContext = null;
481 this.topEventLoop = null;
482 this.fromCommandLine = null;
483 this.isWorker = null;
484 this.supportsWorkers = null;
485 this.isolates = null;
486 this.mainManager = null;
487 this.managers = null;
488 this[_nativeDetectEnvironment]();
489 this.topEventLoop = new _EventLoop();
490 this.isolates = core.Map$(core.int, _IsolateContext).new();
491 this.managers = core.Map$(core.int, dart.dynamic).new();
492 if (dart.notNull(this.isWorker)) {
493 this.mainManager = new _MainManagerStub();
494 this[_nativeInitWorkerMessageHandler]();
495 }
496 }
497 [_nativeDetectEnvironment]() {
498 let isWindowDefined = exports.globalWindow != null;
499 let isWorkerDefined = exports.globalWorker != null;
500 this.isWorker = !dart.notNull(isWindowDefined) && dart.notNull(exports.glo balPostMessageDefined);
501 this.supportsWorkers = dart.notNull(this.isWorker) || dart.notNull(isWorke rDefined) && IsolateNatives.thisScript != null;
502 this.fromCommandLine = !dart.notNull(isWindowDefined) && !dart.notNull(thi s.isWorker);
503 }
504 [_nativeInitWorkerMessageHandler]() {
505 let func = (function(f, a) {
506 return function(e) {
507 f(a, e);
508 };
509 })(IsolateNatives._processWorkerMessage, this.mainManager);
510 self.onmessage = func;
511 self.dartPrint = self.dartPrint || (function(serialize) {
512 return function(object) {
513 if (self.console && self.console.log) {
514 self.console.log(object);
515 } else {
516 self.postMessage(serialize(object));
517 }
518 };
519 })(_Manager._serializePrintMessage);
520 }
521 static _serializePrintMessage(object) {
522 return _serializeMessage(dart.map({command: "print", msg: object}));
523 }
524 maybeCloseWorker() {
525 if (dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty) && this.topEventLoop[_activeJsAsyncCount] == 0) {
526 this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close '})));
527 }
528 }
529 }
530 dart.setSignature(_Manager, {
531 constructors: () => ({_Manager: [_Manager, [core.Function]]}),
532 methods: () => ({
533 [_nativeDetectEnvironment]: [dart.void, []],
534 [_nativeInitWorkerMessageHandler]: [dart.void, []],
535 maybeCloseWorker: [dart.void, []]
536 }),
537 statics: () => ({_serializePrintMessage: [dart.dynamic, [dart.dynamic]]}),
538 names: ['_serializePrintMessage']
539 });
540 let _scheduledControlEvents = Symbol('_scheduledControlEvents');
541 let _isExecutingEvent = Symbol('_isExecutingEvent');
542 let _updateGlobalState = Symbol('_updateGlobalState');
543 let _setGlobals = Symbol('_setGlobals');
544 let _addRegistration = Symbol('_addRegistration');
545 let _close = Symbol('_close');
546 class _IsolateContext extends core.Object {
547 _IsolateContext() {
548 this.id = (() => {
549 let o = exports._globalState, x = o.nextIsolateId;
550 o.nextIsolateId = dart.notNull(x) + 1;
551 return x;
552 })();
553 this.ports = core.Map$(core.int, RawReceivePortImpl).new();
554 this.weakPorts = core.Set$(core.int).new();
555 this.isolateStatics = _foreign_helper.JS_CREATE_ISOLATE();
556 this.controlPort = new RawReceivePortImpl._controlPort();
557 this.pauseCapability = isolate.Capability.new();
558 this.terminateCapability = isolate.Capability.new();
559 this.delayedEvents = dart.list([], _IsolateEvent);
560 this.pauseTokens = core.Set$(isolate.Capability).new();
561 this.errorPorts = core.Set$(isolate.SendPort).new();
562 this.initialized = false;
563 this.isPaused = false;
564 this.doneHandlers = null;
565 this[_scheduledControlEvents] = null;
566 this[_isExecutingEvent] = false;
567 this.errorsAreFatal = true;
568 this.registerWeak(this.controlPort[_id], this.controlPort);
569 }
570 addPause(authentification, resume) {
571 if (!dart.equals(this.pauseCapability, authentification))
572 return;
573 if (dart.notNull(this.pauseTokens.add(resume)) && !dart.notNull(this.isPau sed)) {
574 this.isPaused = true;
575 }
576 this[_updateGlobalState]();
577 }
578 removePause(resume) {
579 if (!dart.notNull(this.isPaused))
580 return;
581 this.pauseTokens.remove(resume);
582 if (dart.notNull(this.pauseTokens.isEmpty)) {
583 while (dart.notNull(this.delayedEvents[dartx.isNotEmpty])) {
584 let event = this.delayedEvents[dartx.removeLast]();
585 exports._globalState.topEventLoop.prequeue(event);
586 }
587 this.isPaused = false;
588 }
589 this[_updateGlobalState]();
590 }
591 addDoneListener(responsePort) {
592 if (this.doneHandlers == null) {
593 this.doneHandlers = [];
594 }
595 if (dart.notNull(dart.as(dart.dsend(this.doneHandlers, 'contains', respons ePort), core.bool)))
596 return;
597 dart.dsend(this.doneHandlers, 'add', responsePort);
598 }
599 removeDoneListener(responsePort) {
600 if (this.doneHandlers == null)
601 return;
602 dart.dsend(this.doneHandlers, 'remove', responsePort);
603 }
604 setErrorsFatal(authentification, errorsAreFatal) {
605 if (!dart.equals(this.terminateCapability, authentification))
606 return;
607 this.errorsAreFatal = errorsAreFatal;
608 }
609 handlePing(responsePort, pingType) {
610 if (pingType == isolate.Isolate.IMMEDIATE || pingType == isolate.Isolate.B EFORE_NEXT_EVENT && !dart.notNull(this[_isExecutingEvent])) {
611 responsePort.send(null);
612 return;
613 }
614 function respond() {
615 responsePort.send(null);
616 }
617 dart.fn(respond, dart.void, []);
618 if (pingType == isolate.Isolate.AS_EVENT) {
619 exports._globalState.topEventLoop.enqueue(this, respond, "ping");
620 return;
621 }
622 dart.assert(pingType == isolate.Isolate.BEFORE_NEXT_EVENT);
623 if (this[_scheduledControlEvents] == null) {
624 this[_scheduledControlEvents] = collection.Queue.new();
625 }
626 dart.dsend(this[_scheduledControlEvents], 'addLast', respond);
627 }
628 handleKill(authentification, priority) {
629 if (!dart.equals(this.terminateCapability, authentification))
630 return;
631 if (priority == isolate.Isolate.IMMEDIATE || priority == isolate.Isolate.B EFORE_NEXT_EVENT && !dart.notNull(this[_isExecutingEvent])) {
632 this.kill();
633 return;
634 }
635 if (priority == isolate.Isolate.AS_EVENT) {
636 exports._globalState.topEventLoop.enqueue(this, dart.bind(this, 'kill'), "kill");
637 return;
638 }
639 dart.assert(priority == isolate.Isolate.BEFORE_NEXT_EVENT);
640 if (this[_scheduledControlEvents] == null) {
641 this[_scheduledControlEvents] = collection.Queue.new();
642 }
643 dart.dsend(this[_scheduledControlEvents], 'addLast', dart.bind(this, 'kill '));
644 }
645 addErrorListener(port) {
646 this.errorPorts.add(port);
647 }
648 removeErrorListener(port) {
649 this.errorPorts.remove(port);
650 }
651 handleUncaughtError(error, stackTrace) {
652 if (dart.notNull(this.errorPorts.isEmpty)) {
653 if (dart.notNull(this.errorsAreFatal) && dart.notNull(core.identical(thi s, exports._globalState.rootContext))) {
654 return;
655 }
656 if (self.console && self.console.error) {
657 self.console.error(error, stackTrace);
658 } else {
659 core.print(error);
660 if (stackTrace != null)
661 core.print(stackTrace);
662 }
663 return;
664 }
665 let message = core.List.new(2);
666 message[dartx.set](0, dart.toString(error));
667 message[dartx.set](1, stackTrace == null ? null : dart.toString(stackTrace ));
668 for (let port of this.errorPorts)
669 port.send(message);
670 }
671 eval(code) {
672 let old = exports._globalState.currentContext;
673 exports._globalState.currentContext = this;
674 this[_setGlobals]();
675 let result = null;
676 this[_isExecutingEvent] = true;
677 try {
678 result = dart.dcall(code);
679 } catch (e) {
680 let s = dart.stackTrace(e);
681 this.handleUncaughtError(e, s);
682 if (dart.notNull(this.errorsAreFatal)) {
683 this.kill();
684 if (dart.notNull(core.identical(this, exports._globalState.rootContext ))) {
685 throw e;
686 }
687 }
688 }
689 finally {
690 this[_isExecutingEvent] = false;
691 exports._globalState.currentContext = old;
692 if (old != null)
693 old[_setGlobals]();
694 if (this[_scheduledControlEvents] != null) {
695 while (dart.notNull(dart.as(dart.dload(this[_scheduledControlEvents], 'isNotEmpty'), core.bool))) {
696 dart.dcall(dart.dsend(this[_scheduledControlEvents], 'removeFirst')) ;
697 }
698 }
699 }
700 return result;
701 }
702 [_setGlobals]() {
703 _foreign_helper.JS_SET_CURRENT_ISOLATE(this.isolateStatics);
704 }
705 handleControlMessage(message) {
706 switch (dart.dindex(message, 0)) {
707 case "pause":
708 {
709 this.addPause(dart.as(dart.dindex(message, 1), isolate.Capability), da rt.as(dart.dindex(message, 2), isolate.Capability));
710 break;
711 }
712 case "resume":
713 {
714 this.removePause(dart.as(dart.dindex(message, 1), isolate.Capability)) ;
715 break;
716 }
717 case 'add-ondone':
718 {
719 this.addDoneListener(dart.as(dart.dindex(message, 1), isolate.SendPort ));
720 break;
721 }
722 case 'remove-ondone':
723 {
724 this.removeDoneListener(dart.as(dart.dindex(message, 1), isolate.SendP ort));
725 break;
726 }
727 case 'set-errors-fatal':
728 {
729 this.setErrorsFatal(dart.as(dart.dindex(message, 1), isolate.Capabilit y), dart.as(dart.dindex(message, 2), core.bool));
730 break;
731 }
732 case "ping":
733 {
734 this.handlePing(dart.as(dart.dindex(message, 1), isolate.SendPort), da rt.as(dart.dindex(message, 2), core.int));
735 break;
736 }
737 case "kill":
738 {
739 this.handleKill(dart.as(dart.dindex(message, 1), isolate.Capability), dart.as(dart.dindex(message, 2), core.int));
740 break;
741 }
742 case "getErrors":
743 {
744 this.addErrorListener(dart.as(dart.dindex(message, 1), isolate.SendPor t));
745 break;
746 }
747 case "stopErrors":
748 {
749 this.removeErrorListener(dart.as(dart.dindex(message, 1), isolate.Send Port));
750 break;
751 }
752 default:
753 }
754 }
755 lookup(portId) {
756 return this.ports.get(portId);
757 }
758 [_addRegistration](portId, port) {
759 if (dart.notNull(this.ports.containsKey(portId))) {
760 dart.throw(core.Exception.new("Registry: ports must be registered only o nce."));
761 }
762 this.ports.set(portId, port);
763 }
764 register(portId, port) {
765 this[_addRegistration](portId, port);
766 this[_updateGlobalState]();
767 }
768 registerWeak(portId, port) {
769 this.weakPorts.add(portId);
770 this[_addRegistration](portId, port);
771 }
772 [_updateGlobalState]() {
773 if (dart.notNull(this.ports.length) - dart.notNull(this.weakPorts.length) > 0 || dart.notNull(this.isPaused) || !dart.notNull(this.initialized)) {
774 exports._globalState.isolates.set(this.id, this);
775 } else {
776 this.kill();
777 }
778 }
779 kill() {
780 if (this[_scheduledControlEvents] != null) {
781 dart.dsend(this[_scheduledControlEvents], 'clear');
782 }
783 for (let port of this.ports.values) {
784 port[_close]();
785 }
786 this.ports.clear();
787 this.weakPorts.clear();
788 exports._globalState.isolates.remove(this.id);
789 this.errorPorts.clear();
790 if (this.doneHandlers != null) {
791 for (let port of dart.as(this.doneHandlers, core.Iterable$(isolate.SendP ort))) {
792 port.send(null);
793 }
794 this.doneHandlers = null;
795 }
796 }
797 unregister(portId) {
798 this.ports.remove(portId);
799 this.weakPorts.remove(portId);
800 this[_updateGlobalState]();
801 }
802 }
803 _IsolateContext[dart.implements] = () => [_foreign_helper.IsolateContext];
804 dart.setSignature(_IsolateContext, {
805 constructors: () => ({_IsolateContext: [_IsolateContext, []]}),
806 methods: () => ({
807 addPause: [dart.void, [isolate.Capability, isolate.Capability]],
808 removePause: [dart.void, [isolate.Capability]],
809 addDoneListener: [dart.void, [isolate.SendPort]],
810 removeDoneListener: [dart.void, [isolate.SendPort]],
811 setErrorsFatal: [dart.void, [isolate.Capability, core.bool]],
812 handlePing: [dart.void, [isolate.SendPort, core.int]],
813 handleKill: [dart.void, [isolate.Capability, core.int]],
814 addErrorListener: [dart.void, [isolate.SendPort]],
815 removeErrorListener: [dart.void, [isolate.SendPort]],
816 handleUncaughtError: [dart.void, [dart.dynamic, core.StackTrace]],
817 eval: [dart.dynamic, [core.Function]],
818 [_setGlobals]: [dart.void, []],
819 handleControlMessage: [dart.void, [dart.dynamic]],
820 lookup: [RawReceivePortImpl, [core.int]],
821 [_addRegistration]: [dart.void, [core.int, RawReceivePortImpl]],
822 register: [dart.void, [core.int, RawReceivePortImpl]],
823 registerWeak: [dart.void, [core.int, RawReceivePortImpl]],
824 [_updateGlobalState]: [dart.void, []],
825 kill: [dart.void, []],
826 unregister: [dart.void, [core.int]]
827 })
828 });
829 let _runHelper = Symbol('_runHelper');
830 class _EventLoop extends core.Object {
831 _EventLoop() {
832 this.events = collection.Queue$(_IsolateEvent).new();
833 this[_activeJsAsyncCount] = 0;
834 }
835 enqueue(isolate, fn, msg) {
836 this.events.addLast(new _IsolateEvent(dart.as(isolate, _IsolateContext), d art.as(fn, core.Function), dart.as(msg, core.String)));
837 }
838 prequeue(event) {
839 this.events.addFirst(event);
840 }
841 dequeue() {
842 if (dart.notNull(this.events.isEmpty))
843 return null;
844 return this.events.removeFirst();
845 }
846 checkOpenReceivePortsFromCommandLine() {
847 if (exports._globalState.rootContext != null && dart.notNull(exports._glob alState.isolates.containsKey(exports._globalState.rootContext.id)) && dart.notNu ll(exports._globalState.fromCommandLine) && dart.notNull(exports._globalState.ro otContext.ports.isEmpty)) {
848 dart.throw(core.Exception.new("Program exited with open ReceivePorts.")) ;
849 }
850 }
851 runIteration() {
852 let event = this.dequeue();
853 if (event == null) {
854 this.checkOpenReceivePortsFromCommandLine();
855 exports._globalState.maybeCloseWorker();
856 return false;
857 }
858 event.process();
859 return true;
860 }
861 [_runHelper]() {
862 if (exports.globalWindow != null) {
863 let next = (function() {
864 if (!dart.notNull(this.runIteration()))
865 return;
866 async.Timer.run(next);
867 }).bind(this);
868 dart.fn(next);
869 next();
870 } else {
871 while (dart.notNull(this.runIteration())) {
872 }
873 }
874 }
875 run() {
876 if (!dart.notNull(exports._globalState.isWorker)) {
877 this[_runHelper]();
878 } else {
879 try {
880 this[_runHelper]();
881 } catch (e) {
882 let trace = dart.stackTrace(e);
883 exports._globalState.mainManager.postMessage(_serializeMessage(dart.ma p({command: 'error', msg: `${e}\n${trace}`})));
884 }
885
886 }
887 }
888 }
889 dart.setSignature(_EventLoop, {
890 constructors: () => ({_EventLoop: [_EventLoop, []]}),
891 methods: () => ({
892 enqueue: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
893 prequeue: [dart.void, [_IsolateEvent]],
894 dequeue: [_IsolateEvent, []],
895 checkOpenReceivePortsFromCommandLine: [dart.void, []],
896 runIteration: [core.bool, []],
897 [_runHelper]: [dart.void, []],
898 run: [dart.void, []]
899 })
900 });
901 class _IsolateEvent extends core.Object {
902 _IsolateEvent(isolate, fn, message) {
903 this.isolate = isolate;
904 this.fn = fn;
905 this.message = message;
906 }
907 process() {
908 if (dart.notNull(this.isolate.isPaused)) {
909 this.isolate.delayedEvents[dartx.add](this);
910 return;
911 }
912 this.isolate.eval(this.fn);
913 }
914 }
915 dart.setSignature(_IsolateEvent, {
916 constructors: () => ({_IsolateEvent: [_IsolateEvent, [_IsolateContext, core. Function, core.String]]}),
917 methods: () => ({process: [dart.void, []]})
918 });
919 dart.defineLazyProperties(exports, {
920 get _global() {
921 return typeof global == 'undefined' ? self : global;
922 }
923 });
924 class _MainManagerStub extends core.Object {
925 postMessage(msg) {
926 exports._global.postMessage(msg);
927 }
928 }
929 dart.setSignature(_MainManagerStub, {
930 methods: () => ({postMessage: [dart.void, [dart.dynamic]]})
931 });
932 let _SPAWNED_SIGNAL = "spawned";
933 let _SPAWN_FAILED_SIGNAL = "spawn failed";
934 dart.copyProperties(exports, {
935 get globalWindow() {
936 return exports._global.window;
937 },
938 get globalWorker() {
939 return exports._global.Worker;
940 },
941 get globalPostMessageDefined() {
942 return !!exports._global.postMessage;
943 }
944 });
945 let _MainFunction = dart.typedef('_MainFunction', () => dart.functionType(dart .dynamic, []));
946 let _MainFunctionArgs = dart.typedef('_MainFunctionArgs', () => dart.functionT ype(dart.dynamic, [dart.dynamic]));
947 let _MainFunctionArgsMessage = dart.typedef('_MainFunctionArgsMessage', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
948 class IsolateNatives extends core.Object {
949 static computeThisScript() {
950 let currentScript = document.currentScript;
951 if (currentScript != null) {
952 return String(currentScript.src);
953 }
954 if (dart.notNull(_js_helper.Primitives.isD8))
955 return IsolateNatives.computeThisScriptD8();
956 if (dart.notNull(_js_helper.Primitives.isJsshell))
957 return IsolateNatives.computeThisScriptJsshell();
958 if (exports._globalState != null && dart.notNull(exports._globalState.isWo rker)) {
959 return IsolateNatives.computeThisScriptFromTrace();
960 }
961 return null;
962 }
963 static computeThisScriptJsshell() {
964 return dart.as(thisFilename(), core.String);
965 }
966 static computeThisScriptD8() {
967 return IsolateNatives.computeThisScriptFromTrace();
968 }
969 static computeThisScriptFromTrace() {
970 let stack = new Error().stack;
971 if (stack == null) {
972 stack = (function() {
973 try {
974 throw new Error();
975 } catch (e) {
976 return e.stack;
977 }
978
979 })();
980 if (stack == null)
981 dart.throw(new core.UnsupportedError('No stack trace'));
982 }
983 let pattern = null, matches = null;
984 pattern = new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m");
985 matches = stack.match(pattern);
986 if (matches != null)
987 return matches[1];
988 pattern = new RegExp("^[^@]*@(.*):[0-9]*$", "m");
989 matches = stack.match(pattern);
990 if (matches != null)
991 return matches[1];
992 dart.throw(new core.UnsupportedError(`Cannot extract URI from "${stack}"`) );
993 }
994 static _getEventData(e) {
995 return e.data;
996 }
997 static _processWorkerMessage(sender, e) {
998 let msg = _deserializeMessage(IsolateNatives._getEventData(e));
999 switch (dart.dindex(msg, 'command')) {
1000 case 'start':
1001 {
1002 exports._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id') , core.int);
1003 let functionName = dart.as(dart.dindex(msg, 'functionName'), core.Stri ng);
1004 let entryPoint = functionName == null ? exports._globalState.entry : d art.as(IsolateNatives._getJSFunctionFromName(functionName), core.Function);
1005 let args = dart.dindex(msg, 'args');
1006 let message = _deserializeMessage(dart.dindex(msg, 'msg'));
1007 let isSpawnUri = dart.dindex(msg, 'isSpawnUri');
1008 let startPaused = dart.dindex(msg, 'startPaused');
1009 let replyTo = _deserializeMessage(dart.dindex(msg, 'replyTo'));
1010 let context = new _IsolateContext();
1011 exports._globalState.topEventLoop.enqueue(context, dart.fn(() => {
1012 IsolateNatives._startIsolate(entryPoint, dart.as(args, core.List$(co re.String)), message, dart.as(isSpawnUri, core.bool), dart.as(startPaused, core. bool), dart.as(replyTo, isolate.SendPort));
1013 }), 'worker-start');
1014 exports._globalState.currentContext = context;
1015 exports._globalState.topEventLoop.run();
1016 break;
1017 }
1018 case 'spawn-worker':
1019 {
1020 if (IsolateNatives.enableSpawnWorker != null)
1021 IsolateNatives.handleSpawnWorkerRequest(msg);
1022 break;
1023 }
1024 case 'message':
1025 {
1026 let port = dart.as(dart.dindex(msg, 'port'), isolate.SendPort);
1027 if (port != null) {
1028 dart.dsend(dart.dindex(msg, 'port'), 'send', dart.dindex(msg, 'msg') );
1029 }
1030 exports._globalState.topEventLoop.run();
1031 break;
1032 }
1033 case 'close':
1034 {
1035 exports._globalState.managers.remove(IsolateNatives.workerIds.get(send er));
1036 sender.terminate();
1037 exports._globalState.topEventLoop.run();
1038 break;
1039 }
1040 case 'log':
1041 {
1042 IsolateNatives._log(dart.dindex(msg, 'msg'));
1043 break;
1044 }
1045 case 'print':
1046 {
1047 if (dart.notNull(exports._globalState.isWorker)) {
1048 exports._globalState.mainManager.postMessage(_serializeMessage(dart. map({command: 'print', msg: msg})));
1049 } else {
1050 core.print(dart.dindex(msg, 'msg'));
1051 }
1052 break;
1053 }
1054 case 'error':
1055 {
1056 dart.throw(dart.dindex(msg, 'msg'));
1057 }
1058 }
1059 }
1060 static handleSpawnWorkerRequest(msg) {
1061 let replyPort = dart.dindex(msg, 'replyPort');
1062 IsolateNatives.spawn(dart.as(dart.dindex(msg, 'functionName'), core.String ), dart.as(dart.dindex(msg, 'uri'), core.String), dart.as(dart.dindex(msg, 'args '), core.List$(core.String)), dart.dindex(msg, 'msg'), false, dart.as(dart.dinde x(msg, 'isSpawnUri'), core.bool), dart.as(dart.dindex(msg, 'startPaused'), core. bool)).then(dart.fn(msg => {
1063 dart.dsend(replyPort, 'send', msg);
1064 }), {onError: dart.fn(errorMessage => {
1065 dart.dsend(replyPort, 'send', [_SPAWN_FAILED_SIGNAL, errorMessage]);
1066 }, dart.dynamic, [core.String])});
1067 }
1068 static _log(msg) {
1069 if (dart.notNull(exports._globalState.isWorker)) {
1070 exports._globalState.mainManager.postMessage(_serializeMessage(dart.map( {command: 'log', msg: msg})));
1071 } else {
1072 try {
1073 IsolateNatives._consoleLog(msg);
1074 } catch (e) {
1075 let trace = dart.stackTrace(e);
1076 dart.throw(core.Exception.new(trace));
1077 }
1078
1079 }
1080 }
1081 static _consoleLog(msg) {
1082 self.console.log(msg);
1083 }
1084 static _getJSFunctionFromName(functionName) {
1085 let globalFunctionsContainer = _foreign_helper.JS_EMBEDDED_GLOBAL("", _js_ embedded_names.GLOBAL_FUNCTIONS);
1086 return globalFunctionsContainer[functionName]();
1087 }
1088 static _getJSFunctionName(f) {
1089 return dart.as(f.$name, core.String);
1090 }
1091 static _allocate(ctor) {
1092 return new ctor();
1093 }
1094 static spawnFunction(topLevelFunction, message, startPaused) {
1095 IsolateNatives.enableSpawnWorker = true;
1096 let name = IsolateNatives._getJSFunctionName(topLevelFunction);
1097 if (name == null) {
1098 dart.throw(new core.UnsupportedError("only top-level functions can be sp awned."));
1099 }
1100 let isLight = false;
1101 let isSpawnUri = false;
1102 return IsolateNatives.spawn(name, null, null, message, isLight, isSpawnUri , startPaused);
1103 }
1104 static spawnUri(uri, args, message, startPaused) {
1105 IsolateNatives.enableSpawnWorker = true;
1106 let isLight = false;
1107 let isSpawnUri = true;
1108 return IsolateNatives.spawn(null, dart.toString(uri), args, message, isLig ht, isSpawnUri, startPaused);
1109 }
1110 static spawn(functionName, uri, args, message, isLight, isSpawnUri, startPau sed) {
1111 if (uri != null && dart.notNull(uri[dartx.endsWith](".dart"))) {
1112 uri = dart.notNull(uri) + ".js";
1113 }
1114 let port = isolate.ReceivePort.new();
1115 let completer = async.Completer$(core.List).new();
1116 port.first.then(dart.fn(msg => {
1117 if (dart.equals(dart.dindex(msg, 0), _SPAWNED_SIGNAL)) {
1118 completer.complete(msg);
1119 } else {
1120 dart.assert(dart.equals(dart.dindex(msg, 0), _SPAWN_FAILED_SIGNAL));
1121 completer.completeError(dart.dindex(msg, 1));
1122 }
1123 }));
1124 let signalReply = port.sendPort;
1125 if (dart.notNull(exports._globalState.useWorkers) && !dart.notNull(isLight )) {
1126 IsolateNatives._startWorker(functionName, uri, args, message, isSpawnUri , startPaused, signalReply, dart.fn(message => completer.completeError(message), dart.void, [core.String]));
1127 } else {
1128 IsolateNatives._startNonWorker(functionName, uri, args, message, isSpawn Uri, startPaused, signalReply);
1129 }
1130 return completer.future;
1131 }
1132 static _startWorker(functionName, uri, args, message, isSpawnUri, startPause d, replyPort, onError) {
1133 if (args != null)
1134 args = core.List$(core.String).from(args);
1135 if (dart.notNull(exports._globalState.isWorker)) {
1136 exports._globalState.mainManager.postMessage(_serializeMessage(dart.map( {command: 'spawn-worker', functionName: functionName, args: args, msg: message, uri: uri, isSpawnUri: isSpawnUri, startPaused: startPaused, replyPort: replyPort })));
1137 } else {
1138 IsolateNatives._spawnWorker(functionName, uri, args, message, isSpawnUri , startPaused, replyPort, onError);
1139 }
1140 }
1141 static _startNonWorker(functionName, uri, args, message, isSpawnUri, startPa used, replyPort) {
1142 if (uri != null) {
1143 dart.throw(new core.UnsupportedError("Currently spawnUri is not supporte d without web workers."));
1144 }
1145 message = _clone(message);
1146 if (args != null)
1147 args = core.List$(core.String).from(args);
1148 exports._globalState.topEventLoop.enqueue(new _IsolateContext(), dart.fn(( ) => {
1149 let func = IsolateNatives._getJSFunctionFromName(functionName);
1150 IsolateNatives._startIsolate(dart.as(func, core.Function), args, message , isSpawnUri, startPaused, replyPort);
1151 }), 'nonworker start');
1152 }
1153 static get currentIsolate() {
1154 let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _Isola teContext);
1155 return new isolate.Isolate(context.controlPort.sendPort, {pauseCapability: context.pauseCapability, terminateCapability: context.terminateCapability});
1156 }
1157 static _startIsolate(topLevel, args, message, isSpawnUri, startPaused, reply To) {
1158 let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _Isola teContext);
1159 _js_helper.Primitives.initializeStatics(context.id);
1160 replyTo.send([_SPAWNED_SIGNAL, context.controlPort.sendPort, context.pause Capability, context.terminateCapability]);
1161 function runStartFunction() {
1162 context.initialized = true;
1163 if (!dart.notNull(isSpawnUri)) {
1164 dart.dcall(topLevel, message);
1165 } else if (dart.is(topLevel, _MainFunctionArgsMessage)) {
1166 dart.dcall(topLevel, args, message);
1167 } else if (dart.is(topLevel, _MainFunctionArgs)) {
1168 dart.dcall(topLevel, args);
1169 } else {
1170 dart.dcall(topLevel);
1171 }
1172 }
1173 dart.fn(runStartFunction, dart.void, []);
1174 if (dart.notNull(startPaused)) {
1175 context.addPause(context.pauseCapability, context.pauseCapability);
1176 exports._globalState.topEventLoop.enqueue(context, runStartFunction, 'st art isolate');
1177 } else {
1178 runStartFunction();
1179 }
1180 }
1181 static _spawnWorker(functionName, uri, args, message, isSpawnUri, startPause d, replyPort, onError) {
1182 if (uri == null)
1183 uri = IsolateNatives.thisScript;
1184 let worker = new Worker(uri);
1185 let onerrorTrampoline = (function(f, u, c) {
1186 return function(e) {
1187 return f(e, u, c);
1188 };
1189 })(IsolateNatives.workerOnError, uri, onError);
1190 worker.onerror = onerrorTrampoline;
1191 let processWorkerMessageTrampoline = (function(f, a) {
1192 return function(e) {
1193 e.onerror = null;
1194 return f(a, e);
1195 };
1196 })(IsolateNatives._processWorkerMessage, worker);
1197 worker.onmessage = processWorkerMessageTrampoline;
1198 let o = exports._globalState;
1199 let workerId = o.nextManagerId;
1200 o.nextManagerId = dart.notNull(workerId) + 1;
1201 IsolateNatives.workerIds.set(worker, workerId);
1202 exports._globalState.managers.set(workerId, worker);
1203 worker.postMessage(_serializeMessage(dart.map({command: 'start', id: worke rId, replyTo: _serializeMessage(replyPort), args: args, msg: _serializeMessage(m essage), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functio nName})));
1204 }
1205 static workerOnError(event, uri, onError) {
1206 event.preventDefault();
1207 let message = dart.as(event.message, core.String);
1208 if (message == null) {
1209 message = `Error spawning worker for ${uri}`;
1210 } else {
1211 message = `Error spawning worker for ${uri} (${message})`;
1212 }
1213 onError(message);
1214 return true;
1215 }
1216 }
1217 dart.setSignature(IsolateNatives, {
1218 statics: () => ({
1219 computeThisScript: [core.String, []],
1220 computeThisScriptJsshell: [core.String, []],
1221 computeThisScriptD8: [core.String, []],
1222 computeThisScriptFromTrace: [core.String, []],
1223 _getEventData: [dart.dynamic, [dart.dynamic]],
1224 _processWorkerMessage: [dart.void, [dart.dynamic, dart.dynamic]],
1225 handleSpawnWorkerRequest: [dart.dynamic, [dart.dynamic]],
1226 _log: [dart.dynamic, [dart.dynamic]],
1227 _consoleLog: [dart.void, [dart.dynamic]],
1228 _getJSFunctionFromName: [dart.dynamic, [core.String]],
1229 _getJSFunctionName: [core.String, [core.Function]],
1230 _allocate: [dart.dynamic, [dart.dynamic]],
1231 spawnFunction: [async.Future$(core.List), [dart.functionType(dart.void, [d art.dynamic]), dart.dynamic, core.bool]],
1232 spawnUri: [async.Future$(core.List), [core.Uri, core.List$(core.String), d art.dynamic, core.bool]],
1233 spawn: [async.Future$(core.List), [core.String, core.String, core.List$(co re.String), dart.dynamic, core.bool, core.bool, core.bool]],
1234 _startWorker: [dart.void, [core.String, core.String, core.List$(core.Strin g), dart.dynamic, core.bool, core.bool, isolate.SendPort, dart.functionType(dart .void, [core.String])]],
1235 _startNonWorker: [dart.void, [core.String, core.String, core.List$(core.St ring), dart.dynamic, core.bool, core.bool, isolate.SendPort]],
1236 _startIsolate: [dart.void, [core.Function, core.List$(core.String), dart.d ynamic, core.bool, core.bool, isolate.SendPort]],
1237 _spawnWorker: [dart.void, [dart.dynamic, core.String, core.List$(core.Stri ng), dart.dynamic, core.bool, core.bool, isolate.SendPort, dart.functionType(dar t.void, [core.String])]],
1238 workerOnError: [core.bool, [dart.dynamic, core.String, dart.functionType(d art.void, [core.String])]]
1239 }),
1240 names: ['computeThisScript', 'computeThisScriptJsshell', 'computeThisScriptD 8', 'computeThisScriptFromTrace', '_getEventData', '_processWorkerMessage', 'han dleSpawnWorkerRequest', '_log', '_consoleLog', '_getJSFunctionFromName', '_getJS FunctionName', '_allocate', 'spawnFunction', 'spawnUri', 'spawn', '_startWorker' , '_startNonWorker', '_startIsolate', '_spawnWorker', 'workerOnError']
1241 });
1242 IsolateNatives.enableSpawnWorker = null;
1243 dart.defineLazyProperties(IsolateNatives, {
1244 get thisScript() {
1245 return IsolateNatives.computeThisScript();
1246 },
1247 set thisScript(_) {},
1248 get workerIds() {
1249 return new (core.Expando$(core.int))();
1250 }
1251 });
1252 let _checkReplyTo = Symbol('_checkReplyTo');
1253 class _BaseSendPort extends core.Object {
1254 _BaseSendPort(isolateId) {
1255 this[_isolateId] = isolateId;
1256 }
1257 [_checkReplyTo](replyTo) {
1258 if (replyTo != null && !dart.is(replyTo, _NativeJsSendPort) && !dart.is(re plyTo, _WorkerSendPort)) {
1259 dart.throw(core.Exception.new("SendPort.send: Illegal replyTo port type" ));
1260 }
1261 }
1262 }
1263 _BaseSendPort[dart.implements] = () => [isolate.SendPort];
1264 dart.setSignature(_BaseSendPort, {
1265 constructors: () => ({_BaseSendPort: [_BaseSendPort, [core.int]]}),
1266 methods: () => ({[_checkReplyTo]: [dart.void, [isolate.SendPort]]})
1267 });
1268 let _isClosed = Symbol('_isClosed');
1269 let _add = Symbol('_add');
1270 class _NativeJsSendPort extends _BaseSendPort {
1271 _NativeJsSendPort(receivePort, isolateId) {
1272 this[_receivePort] = receivePort;
1273 super._BaseSendPort(isolateId);
1274 }
1275 send(message) {
1276 let isolate = exports._globalState.isolates.get(this[_isolateId]);
1277 if (isolate == null)
1278 return;
1279 if (dart.notNull(this[_receivePort][_isClosed]))
1280 return;
1281 let msg = _clone(message);
1282 if (dart.equals(isolate.controlPort, this[_receivePort])) {
1283 isolate.handleControlMessage(msg);
1284 return;
1285 }
1286 exports._globalState.topEventLoop.enqueue(isolate, dart.fn((() => {
1287 if (!dart.notNull(this[_receivePort][_isClosed])) {
1288 this[_receivePort][_add](msg);
1289 }
1290 }).bind(this)), `receive ${message}`);
1291 }
1292 ['=='](other) {
1293 return dart.is(other, _NativeJsSendPort) && dart.equals(this[_receivePort] , dart.dload(other, _receivePort));
1294 }
1295 get hashCode() {
1296 return this[_receivePort][_id];
1297 }
1298 }
1299 _NativeJsSendPort[dart.implements] = () => [isolate.SendPort];
1300 dart.setSignature(_NativeJsSendPort, {
1301 constructors: () => ({_NativeJsSendPort: [_NativeJsSendPort, [RawReceivePort Impl, core.int]]}),
1302 methods: () => ({send: [dart.void, [dart.dynamic]]})
1303 });
1304 class _WorkerSendPort extends _BaseSendPort {
1305 _WorkerSendPort(workerId, isolateId, receivePortId) {
1306 this[_workerId] = workerId;
1307 this[_receivePortId] = receivePortId;
1308 super._BaseSendPort(isolateId);
1309 }
1310 send(message) {
1311 let workerMessage = _serializeMessage(dart.map({command: 'message', port: this, msg: message}));
1312 if (dart.notNull(exports._globalState.isWorker)) {
1313 exports._globalState.mainManager.postMessage(workerMessage);
1314 } else {
1315 let manager = exports._globalState.managers.get(this[_workerId]);
1316 if (manager != null) {
1317 manager.postMessage(workerMessage);
1318 }
1319 }
1320 }
1321 ['=='](other) {
1322 return dart.is(other, _WorkerSendPort) && dart.equals(this[_workerId], dar t.dload(other, _workerId)) && dart.equals(this[_isolateId], dart.dload(other, _i solateId)) && dart.equals(this[_receivePortId], dart.dload(other, _receivePortId ));
1323 }
1324 get hashCode() {
1325 return dart.notNull(this[_workerId]) << 16 ^ dart.notNull(this[_isolateId] ) << 8 ^ dart.notNull(this[_receivePortId]);
1326 }
1327 }
1328 _WorkerSendPort[dart.implements] = () => [isolate.SendPort];
1329 dart.setSignature(_WorkerSendPort, {
1330 constructors: () => ({_WorkerSendPort: [_WorkerSendPort, [core.int, core.int , core.int]]}),
1331 methods: () => ({send: [dart.void, [dart.dynamic]]})
1332 });
1333 let _handler = Symbol('_handler');
1334 class RawReceivePortImpl extends core.Object {
1335 RawReceivePortImpl(handler) {
1336 this[_handler] = handler;
1337 this[_id] = (() => {
1338 let x = RawReceivePortImpl._nextFreeId;
1339 RawReceivePortImpl._nextFreeId = dart.notNull(x) + 1;
1340 return x;
1341 })();
1342 this[_isClosed] = false;
1343 exports._globalState.currentContext.register(this[_id], this);
1344 }
1345 weak(handler) {
1346 this[_handler] = handler;
1347 this[_id] = (() => {
1348 let x = RawReceivePortImpl._nextFreeId;
1349 RawReceivePortImpl._nextFreeId = dart.notNull(x) + 1;
1350 return x;
1351 })();
1352 this[_isClosed] = false;
1353 exports._globalState.currentContext.registerWeak(this[_id], this);
1354 }
1355 _controlPort() {
1356 this[_handler] = null;
1357 this[_id] = 0;
1358 this[_isClosed] = false;
1359 }
1360 set handler(newHandler) {
1361 this[_handler] = newHandler;
1362 }
1363 [_close]() {
1364 this[_isClosed] = true;
1365 this[_handler] = null;
1366 }
1367 close() {
1368 if (dart.notNull(this[_isClosed]))
1369 return;
1370 this[_isClosed] = true;
1371 this[_handler] = null;
1372 exports._globalState.currentContext.unregister(this[_id]);
1373 }
1374 [_add](dataEvent) {
1375 if (dart.notNull(this[_isClosed]))
1376 return;
1377 dart.dcall(this[_handler], dataEvent);
1378 }
1379 get sendPort() {
1380 return new _NativeJsSendPort(this, exports._globalState.currentContext.id) ;
1381 }
1382 }
1383 RawReceivePortImpl[dart.implements] = () => [isolate.RawReceivePort];
1384 dart.defineNamedConstructor(RawReceivePortImpl, 'weak');
1385 dart.defineNamedConstructor(RawReceivePortImpl, '_controlPort');
1386 dart.setSignature(RawReceivePortImpl, {
1387 constructors: () => ({
1388 RawReceivePortImpl: [RawReceivePortImpl, [core.Function]],
1389 weak: [RawReceivePortImpl, [core.Function]],
1390 _controlPort: [RawReceivePortImpl, []]
1391 }),
1392 methods: () => ({
1393 [_close]: [dart.void, []],
1394 close: [dart.void, []],
1395 [_add]: [dart.void, [dart.dynamic]]
1396 })
1397 });
1398 RawReceivePortImpl._nextFreeId = 1;
1399 let _rawPort = Symbol('_rawPort');
1400 let _controller = Symbol('_controller');
1401 class ReceivePortImpl extends async.Stream {
1402 ReceivePortImpl() {
1403 this.fromRawReceivePort(new RawReceivePortImpl(null));
1404 }
1405 weak() {
1406 this.fromRawReceivePort(new RawReceivePortImpl.weak(null));
1407 }
1408 fromRawReceivePort(rawPort) {
1409 this[_rawPort] = rawPort;
1410 this[_controller] = null;
1411 super.Stream();
1412 this[_controller] = async.StreamController.new({onCancel: dart.bind(this, 'close'), sync: true});
1413 this[_rawPort].handler = dart.bind(this[_controller], 'add');
1414 }
1415 listen(onData, opts) {
1416 let onError = opts && 'onError' in opts ? opts.onError : null;
1417 let onDone = opts && 'onDone' in opts ? opts.onDone : null;
1418 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
1419 return this[_controller].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
1420 }
1421 close() {
1422 this[_rawPort].close();
1423 this[_controller].close();
1424 }
1425 get sendPort() {
1426 return this[_rawPort].sendPort;
1427 }
1428 }
1429 ReceivePortImpl[dart.implements] = () => [isolate.ReceivePort];
1430 dart.defineNamedConstructor(ReceivePortImpl, 'weak');
1431 dart.defineNamedConstructor(ReceivePortImpl, 'fromRawReceivePort');
1432 dart.setSignature(ReceivePortImpl, {
1433 constructors: () => ({
1434 ReceivePortImpl: [ReceivePortImpl, []],
1435 weak: [ReceivePortImpl, []],
1436 fromRawReceivePort: [ReceivePortImpl, [isolate.RawReceivePort]]
1437 }),
1438 methods: () => ({
1439 listen: [async.StreamSubscription, [dart.functionType(dart.void, [dart.dyn amic])], {onError: core.Function, onDone: dart.functionType(dart.void, []), canc elOnError: core.bool}],
1440 close: [dart.void, []]
1441 })
1442 });
1443 let _once = Symbol('_once');
1444 let _inEventLoop = Symbol('_inEventLoop');
1445 let _handle = Symbol('_handle');
1446 class TimerImpl extends core.Object {
1447 TimerImpl(milliseconds, callback) {
1448 this[_once] = true;
1449 this[_inEventLoop] = false;
1450 this[_handle] = null;
1451 if (milliseconds == 0 && (!dart.notNull(hasTimer()) || dart.notNull(export s._globalState.isWorker))) {
1452 let internalCallback = (function() {
1453 this[_handle] = null;
1454 callback();
1455 }).bind(this);
1456 dart.fn(internalCallback, dart.void, []);
1457 this[_handle] = 1;
1458 exports._globalState.topEventLoop.enqueue(exports._globalState.currentCo ntext, internalCallback, 'timer');
1459 this[_inEventLoop] = true;
1460 } else if (dart.notNull(hasTimer())) {
1461 let internalCallback = (function() {
1462 this[_handle] = null;
1463 leaveJsAsync();
1464 callback();
1465 }).bind(this);
1466 dart.fn(internalCallback, dart.void, []);
1467 enterJsAsync();
1468 this[_handle] = self.setTimeout(internalCallback, milliseconds);
1469 } else {
1470 dart.assert(dart.notNull(milliseconds) > 0);
1471 dart.throw(new core.UnsupportedError("Timer greater than 0."));
1472 }
1473 }
1474 periodic(milliseconds, callback) {
1475 this[_once] = false;
1476 this[_inEventLoop] = false;
1477 this[_handle] = null;
1478 if (dart.notNull(hasTimer())) {
1479 enterJsAsync();
1480 this[_handle] = self.setInterval(dart.fn((() => {
1481 callback(this);
1482 }).bind(this)), milliseconds);
1483 } else {
1484 dart.throw(new core.UnsupportedError("Periodic timer."));
1485 }
1486 }
1487 cancel() {
1488 if (dart.notNull(hasTimer())) {
1489 if (dart.notNull(this[_inEventLoop])) {
1490 dart.throw(new core.UnsupportedError("Timer in event loop cannot be ca nceled."));
1491 }
1492 if (this[_handle] == null)
1493 return;
1494 leaveJsAsync();
1495 if (dart.notNull(this[_once])) {
1496 self.clearTimeout(this[_handle]);
1497 } else {
1498 self.clearInterval(this[_handle]);
1499 }
1500 this[_handle] = null;
1501 } else {
1502 dart.throw(new core.UnsupportedError("Canceling a timer."));
1503 }
1504 }
1505 get isActive() {
1506 return this[_handle] != null;
1507 }
1508 }
1509 TimerImpl[dart.implements] = () => [async.Timer];
1510 dart.defineNamedConstructor(TimerImpl, 'periodic');
1511 dart.setSignature(TimerImpl, {
1512 constructors: () => ({
1513 TimerImpl: [TimerImpl, [core.int, dart.functionType(dart.void, [])]],
1514 periodic: [TimerImpl, [core.int, dart.functionType(dart.void, [async.Timer ])]]
1515 }),
1516 methods: () => ({cancel: [dart.void, []]})
1517 });
1518 function hasTimer() {
1519 return self.setTimeout != null;
1520 }
1521 dart.fn(hasTimer, core.bool, []);
1522 class CapabilityImpl extends core.Object {
1523 CapabilityImpl() {
1524 this._internal(_js_helper.random64());
1525 }
1526 _internal(id) {
1527 this[_id] = id;
1528 }
1529 get hashCode() {
1530 let hash = this[_id];
1531 hash = dart.notNull(hash) >> 0 ^ (dart.notNull(hash) / 4294967296)[dartx.t runcate]();
1532 hash = ~dart.notNull(hash) + (dart.notNull(hash) << 15) & 4294967295;
1533 hash = dart.notNull(hash) ^ dart.notNull(hash) >> 12;
1534 hash = dart.notNull(hash) * 5 & 4294967295;
1535 hash = dart.notNull(hash) ^ dart.notNull(hash) >> 4;
1536 hash = dart.notNull(hash) * 2057 & 4294967295;
1537 hash = dart.notNull(hash) ^ dart.notNull(hash) >> 16;
1538 return hash;
1539 }
1540 ['=='](other) {
1541 if (dart.notNull(core.identical(other, this)))
1542 return true;
1543 if (dart.is(other, CapabilityImpl)) {
1544 return core.identical(this[_id], other[_id]);
1545 }
1546 return false;
1547 }
1548 }
1549 CapabilityImpl[dart.implements] = () => [isolate.Capability];
1550 dart.defineNamedConstructor(CapabilityImpl, '_internal');
1551 dart.setSignature(CapabilityImpl, {
1552 constructors: () => ({
1553 CapabilityImpl: [CapabilityImpl, []],
1554 _internal: [CapabilityImpl, [core.int]]
1555 }),
1556 methods: () => ({'==': [core.bool, [core.Object]]})
1557 });
1558 // Exports:
1559 exports.enterJsAsync = enterJsAsync;
1560 exports.leaveJsAsync = leaveJsAsync;
1561 exports.isWorker = isWorker;
1562 exports.startRootIsolate = startRootIsolate;
1563 exports.IsolateNatives = IsolateNatives;
1564 exports.RawReceivePortImpl = RawReceivePortImpl;
1565 exports.ReceivePortImpl = ReceivePortImpl;
1566 exports.TimerImpl = TimerImpl;
1567 exports.hasTimer = hasTimer;
1568 exports.CapabilityImpl = CapabilityImpl;
1569 });
OLDNEW
« no previous file with comments | « lib/runtime/dart/_internal.js ('k') | lib/runtime/dart/_js_embedded_names.js » ('j') | lib/src/checker/resolver.dart » ('J')

Powered by Google App Engine
This is Rietveld 408576698