Wrapperless dart:html and friends

lib/runtime/dart/_isolate_helper.js

 dart_library.library('dart/_isolate_helper', null, /* Imports */[
   'dart/_runtime',
   'dart/core',
   'dart/_native_typed_data',
   'dart/_interceptors',
   'dart/_js_helper',
   'dart/isolate',
   'dart/_foreign_helper',
   'dart/_js_embedded_names',
   'dart/collection',
@@ skipping 23 matching lines @@
   const _id = Symbol('_id');
   const _receivePort = Symbol('_receivePort');
   class _Serializer extends core.Object {
     _Serializer(opts) {
       let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.serializeSendPorts : true;
       this.serializedObjectIds = core.Map$(dart.dynamic, core.int).identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
       if (dart.notNull(this.isPrimitive(x))) return this.serializePrimitive(x);
-      let serializationId = this.serializedObjectIds.get(x);
+      let serializationId = this.serializedObjectIds[dartx.get](x);
       if (serializationId != null) return this.makeRef(serializationId);
-      serializationId = this.serializedObjectIds.length;
-      this.serializedObjectIds.set(x, serializationId);
+      serializationId = this.serializedObjectIds[dartx.length];
+      this.serializedObjectIds[dartx.set](x, serializationId);
       if (dart.is(x, _native_typed_data.NativeByteBuffer)) return this.serializeByteBuffer(x);
       if (dart.is(x, _native_typed_data.NativeTypedData)) return this.serializeTypedData(x);
       if (dart.is(x, _interceptors.JSIndexable)) return this.serializeJSIndexable(x);
       if (dart.is(x, _js_helper.InternalMap)) return this.serializeMap(x);
       if (dart.is(x, _interceptors.JSObject)) return this.serializeJSObject(x);
       if (dart.is(x, _interceptors.Interceptor)) this.unsupported(x);
       if (dart.is(x, isolate.RawReceivePort)) {
         this.unsupported(x, "RawReceivePorts can't be transmitted:");
       }
       if (dart.is(x, _NativeJsSendPort)) return this.serializeJsSendPort(x);
@@ skipping 40 matching lines @@
       return serialized;
     }
     serializeArrayInPlace(x) {
       for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
         x[dartx.set](i, this.serialize(x[dartx.get](i)));
       }
       return x;
     }
     serializeMap(x) {
       let serializeTearOff = dart.bind(this, 'serialize');
-      return ['map', x.keys[dartx.map](dart.as(serializeTearOff, __CastType0))[dartx.toList](), x.values[dartx.map](dart.as(serializeTearOff, dart.functionType(dart.dynamic, [dart.dynamic])))[dartx.toList]()];
+      return ['map', x[dartx.keys][dartx.map](dart.as(serializeTearOff, __CastType0))[dartx.toList](), x[dartx.values][dartx.map](dart.as(serializeTearOff, dart.functionType(dart.dynamic, [dart.dynamic])))[dartx.toList]()];
     }
     serializeJSObject(x) {
       if (!!x.constructor && x.constructor !== Object) {
         this.unsupported(x, "Only plain JS Objects are supported:");
       }
       let keys = dart.as(Object.keys(x), core.List);
       let values = [];
       values[dartx.length] = keys[dartx.length];
       for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
         values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
@@ skipping 176 matching lines @@
       return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
     }
     deserializeMap(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'map'));
       let keys = dart.as(dart.dindex(x, 1), core.List);
       let values = dart.as(dart.dindex(x, 2), core.List);
       let result = dart.map();
       this.deserializedObjects[dartx.add](result);
       keys = keys[dartx.map](dart.bind(this, 'deserialize'))[dartx.toList]();
       for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
-        result.set(keys[dartx.get](i), this.deserialize(values[dartx.get](i)));
+        result[dartx.set](keys[dartx.get](i), this.deserialize(values[dartx.get](i)));
       }
       return result;
     }
     deserializeSendPort(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'sendport'));
       let managerId = dart.as(dart.dindex(x, 1), core.int);
       let isolateId = dart.as(dart.dindex(x, 2), core.int);
       let receivePortId = dart.as(dart.dindex(x, 3), core.int);
       let result = null;
       if (managerId == exports._globalState.currentManagerId) {
-        let isolate = exports._globalState.isolates.get(isolateId);
+        let isolate = exports._globalState.isolates[dartx.get](isolateId);
         if (isolate == null) return null;
         let receivePort = isolate.lookup(receivePortId);
         if (receivePort == null) return null;
         result = new _NativeJsSendPort(receivePort, isolateId);
       } else {
         result = new _WorkerSendPort(managerId, isolateId, receivePortId);
       }
       this.deserializedObjects[dartx.add](result);
       return result;
     }
@@ skipping 165 matching lines @@
           } else {
             self.postMessage(serialize(object));
           }
         };
       })(_Manager._serializePrintMessage);
     }
     static _serializePrintMessage(object) {
       return _serializeMessage(dart.map({command: "print", msg: object}));
     }
     maybeCloseWorker() {
-      if (dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty) && this.topEventLoop[_activeJsAsyncCount] == 0) {
+      if (dart.notNull(this.isWorker) && dart.notNull(this.isolates[dartx.isEmpty]) && this.topEventLoop[_activeJsAsyncCount] == 0) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
   dart.setSignature(_Manager, {
     constructors: () => ({_Manager: [_Manager, [core.Function]]}),
     methods: () => ({
       [_nativeDetectEnvironment]: [dart.void, []],
       [_nativeInitWorkerMessageHandler]: [dart.void, []],
       maybeCloseWorker: [dart.void, []]
@@ skipping 202 matching lines @@
         }
         case "stopErrors":
         {
           this.removeErrorListener(dart.as(dart.dindex(message, 1), isolate.SendPort));
           break;
         }
         default:
       }
     }
     lookup(portId) {
-      return this.ports.get(portId);
+      return this.ports[dartx.get](portId);
     }
     [_addRegistration](portId, port) {
-      if (dart.notNull(this.ports.containsKey(portId))) {
+      if (dart.notNull(this.ports[dartx.containsKey](portId))) {
         dart.throw(core.Exception.new("Registry: ports must be registered only once."));
       }
-      this.ports.set(portId, port);
+      this.ports[dartx.set](portId, port);
     }
     register(portId, port) {
       this[_addRegistration](portId, port);
       this[_updateGlobalState]();
     }
     registerWeak(portId, port) {
       this.weakPorts.add(portId);
       this[_addRegistration](portId, port);
     }
     [_updateGlobalState]() {
-      if (dart.notNull(this.ports.length) - dart.notNull(this.weakPorts.length) > 0 || dart.notNull(this.isPaused) || !dart.notNull(this.initialized)) {
-        exports._globalState.isolates.set(this.id, this);
+      if (dart.notNull(this.ports[dartx.length]) - dart.notNull(this.weakPorts.length) > 0 || dart.notNull(this.isPaused) || !dart.notNull(this.initialized)) {
+        exports._globalState.isolates[dartx.set](this.id, this);
       } else {
         this.kill();
       }
     }
     kill() {
       if (this[_scheduledControlEvents] != null) {
         dart.dsend(this[_scheduledControlEvents], 'clear');
       }
-      for (let port of this.ports.values) {
+      for (let port of this.ports[dartx.values]) {
         port[_close]();
       }
-      this.ports.clear();
+      this.ports[dartx.clear]();
       this.weakPorts.clear();
-      exports._globalState.isolates.remove(this.id);
+      exports._globalState.isolates[dartx.remove](this.id);
       this.errorPorts.clear();
       if (this.doneHandlers != null) {
         for (let port of dart.as(this.doneHandlers, core.Iterable$(isolate.SendPort))) {
           port.send(null);
         }
         this.doneHandlers = null;
       }
     }
     unregister(portId) {
-      this.ports.remove(portId);
+      this.ports[dartx.remove](portId);
       this.weakPorts.remove(portId);
       this[_updateGlobalState]();
     }
   }
   _IsolateContext[dart.implements] = () => [_foreign_helper.IsolateContext];
   dart.setSignature(_IsolateContext, {
     constructors: () => ({_IsolateContext: [_IsolateContext, []]}),
     methods: () => ({
       addPause: [dart.void, [isolate.Capability, isolate.Capability]],
       removePause: [dart.void, [isolate.Capability]],
@@ skipping 27 matching lines @@
       this.events.addLast(new _IsolateEvent(dart.as(isolate, _IsolateContext), dart.as(fn, core.Function), dart.as(msg, core.String)));
     }
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
       if (dart.notNull(this.events.isEmpty)) return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
-      if (exports._globalState.rootContext != null && dart.notNull(exports._globalState.isolates.containsKey(exports._globalState.rootContext.id)) && dart.notNull(exports._globalState.fromCommandLine) && dart.notNull(exports._globalState.rootContext.ports.isEmpty)) {
+      if (exports._globalState.rootContext != null && dart.notNull(exports._globalState.isolates[dartx.containsKey](exports._globalState.rootContext.id)) && dart.notNull(exports._globalState.fromCommandLine) && dart.notNull(exports._globalState.rootContext.ports[dartx.isEmpty])) {
         dart.throw(core.Exception.new("Program exited with open ReceivePorts."));
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
@@ skipping 156 matching lines @@
         {
           let port = dart.as(dart.dindex(msg, 'port'), isolate.SendPort);
           if (port != null) {
             dart.dsend(dart.dindex(msg, 'port'), 'send', dart.dindex(msg, 'msg'));
           }
           exports._globalState.topEventLoop.run();
           break;
         }
         case 'close':
         {
-          exports._globalState.managers.remove(IsolateNatives.workerIds.get(sender));
+          exports._globalState.managers[dartx.remove](IsolateNatives.workerIds.get(sender));
           sender.terminate();
           exports._globalState.topEventLoop.run();
           break;
         }
         case 'log':
         {
           IsolateNatives._log(dart.dindex(msg, 'msg'));
           break;
         }
         case 'print':
@@ skipping 143 matching lines @@
         return function(e) {
           e.onerror = null;
           return f(a, e);
         };
       })(IsolateNatives._processWorkerMessage, worker);
       worker.onmessage = processWorkerMessageTrampoline;
       let o = exports._globalState;
       let workerId = o.nextManagerId;
       o.nextManagerId = dart.notNull(workerId) + 1;
       IsolateNatives.workerIds.set(worker, workerId);
-      exports._globalState.managers.set(workerId, worker);
+      exports._globalState.managers[dartx.set](workerId, worker);
       worker.postMessage(_serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _serializeMessage(replyPort), args: args, msg: _serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName})));
     }
     static workerOnError(event, uri, onError) {
       event.preventDefault();
       let message = dart.as(event.message, core.String);
       if (message == null) {
         message = `Error spawning worker for ${uri}`;
       } else {
         message = `Error spawning worker for ${uri} (${message})`;
       }
@@ skipping 53 matching lines @@
     methods: () => ({[_checkReplyTo]: [dart.void, [isolate.SendPort]]})
   });
   const _isClosed = Symbol('_isClosed');
   const _add = Symbol('_add');
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort(receivePort, isolateId) {
       this[_receivePort] = receivePort;
       super._BaseSendPort(isolateId);
     }
     send(message) {
-      let isolate = exports._globalState.isolates.get(this[_isolateId]);
+      let isolate = exports._globalState.isolates[dartx.get](this[_isolateId]);
       if (isolate == null) return;
       if (dart.notNull(this[_receivePort][_isClosed])) return;
       let msg = _clone(message);
       if (dart.equals(isolate.controlPort, this[_receivePort])) {
         isolate.handleControlMessage(msg);
         return;
       }
       exports._globalState.topEventLoop.enqueue(isolate, dart.fn(() => {
         if (!dart.notNull(this[_receivePort][_isClosed])) {
           this[_receivePort][_add](msg);
@@ skipping 16 matching lines @@
     _WorkerSendPort(workerId, isolateId, receivePortId) {
       this[_workerId] = workerId;
       this[_receivePortId] = receivePortId;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let workerMessage = _serializeMessage(dart.map({command: 'message', port: this, msg: message}));
       if (dart.notNull(exports._globalState.isWorker)) {
         exports._globalState.mainManager.postMessage(workerMessage);
       } else {
-        let manager = exports._globalState.managers.get(this[_workerId]);
+        let manager = exports._globalState.managers[dartx.get](this[_workerId]);
         if (manager != null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
       return dart.is(other, _WorkerSendPort) && this[_workerId] == other[_workerId] && this[_isolateId] == other[_isolateId] && this[_receivePortId] == other[_receivePortId];
     }
     get hashCode() {
       return dart.notNull(this[_workerId]) << 16 ^ dart.notNull(this[_isolateId]) << 8 ^ dart.notNull(this[_receivePortId]);
@@ skipping 230 matching lines @@
   exports.leaveJsAsync = leaveJsAsync;
   exports.isWorker = isWorker;
   exports.startRootIsolate = startRootIsolate;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 });